Let Your Team Feel Every Win: An Automated “Deal Won” Celebration Alert

You close a chunky new agency account on a Friday afternoon, smile at Stripe, tell yourself you’ll share the news in Slack later… and by Monday, it’s old news you never shared.

Multiply that by a year of quiet wins and you get what most SEO SaaS teams live with: a business that’s growing on paper, while the humans doing the work feel none of it.

The sequence at the top of this page is the whole journey, end to end. It turns every deal_won event from your product or billing system into a light, real‑time internal celebration — without you typing “new deal!” by hand ever again.

This isn’t just vibes. For a 3–5 person SEO SaaS, having the team feel wins in real time is leverage: better morale, sharper focus on what’s working, and fewer “wait, who is this customer?” moments in support and product.

Let’s walk through how to build that in Spreeflo, node by node.

Why “closed‑won alerts” earn their keep in a lean SaaS

Take RankPulse, a fictional but typical SEO SaaS:

• ~400 paying customers at $89/mo

• 3‑person team: founder, engineer, part‑time marketer

• Deals come in from a mix of self‑serve signups and occasional high‑touch agency accounts

Today, new revenue looks like a Stripe email pinging the founder’s inbox. If they remember, they’ll screenshot something into Slack. If they’re deep in a deployment or putting out a fire, the team never hears about it.

The cost of that is subtle:

• Support jumps into tickets with no context that “this is the new $399 agency we just closed.”

• Product doesn’t see patterns in who’s upgrading when they ship certain features.

• The team rarely feels the feedback loop between their work and revenue.

You could fix this with discipline and manual posts. But your whole thesis as a founder is that systems scale better than willpower.

That’s where a tiny internal journey comes in: one that listens for a deal_won event coming from your backend via the Spreeflo API, and fires a short, contextual Send Internal Email to whoever needs to know.

Build it once, and it celebrates every win, forever. That’s exactly the kind of “set‑and‑forget” leverage founder‑led businesses win on.

The shape of the journey you’re building

Before we zoom into each node, here’s what this journey does in plain language:

1. Your backend POSTs an event like deal_won into Spreeflo whenever a subscription goes live, an expansion closes, or an annual plan is paid.

2. A Custom Event trigger listens for that deal_won event.

3. An If/Else node routes “big” vs “standard” deals based on who the customer is.

4. Each branch sends a different Send Internal Email to your team.

5. (Optional) A Webhook also notifies a Slack relay or CRM if you’re on the Professional plan.

6. The flow ends. The same contact can re‑enter next time another deal closes.

The sequence at the top of this page visualizes that exact flow. Let’s unpack why it’s built this way and how to adapt it to your stack.

Step 1: Fire a clean `deal_won` event from your backend

This pattern assumes you already have billing or CRM logic server‑side: Stripe, Paddle, Chargebee, or your own subscription table.

When a deal truly becomes “closed won” (trial converted, failed payments resolved, expansion signed), you want your backend to POST to Spreeflo’s events endpoint with:

• event: deal_won

• email: the customer’s primary contact email

• properties: structured data about the deal (e.g. mrr, plan_tier, billing_period, sales_owner)

Because this runs in your server or worker, it must talk to the Spreeflo API, not the JavaScript SDK. The API documentation in the help center shows the exact JSON shape and authentication header to use.

Why this matters for the journey:

• The email links the event to the right contact in your audience. If the contact doesn’t exist yet, Spreeflo creates it.

• The properties let you tailor alerts: you can highlight big MRR, different plan tiers, or the sales owner.

• Using a single canonical event (deal_won) keeps your automations and analytics simple, instead of juggling trial_converted, expanded_plan, paid_invoice, and so on.

Once this event is flowing into your workspace, you’re ready to wire the journey.

Step 2: Custom Event trigger — listen for every win

Node: Custom Event trigger (deal_won), re‑enrollment ON

In the journey canvas (see the campaigns and journeys overview in the docs if you’re new to the editor), drag in a Custom Event trigger:

• Event name: deal_won

• Add property conditions: off (for now)

• Re‑enrollment: on

Why these choices:

• Custom Event is the right fit because deal_won is a backend signal, not a form submission or tag change.

• You want re‑enrollment on. The same customer might upgrade twice in a year; each one deserves its own alert. With re‑enrollment enabled, every new deal_won event for that contact can re‑start the journey, as long as they’ve exited the previous run.

• Property conditions stay off because we want every closed‑won deal to trigger an alert. We’ll branch “big” vs “standard” inside the journey instead.

Caveat: Spreeflo prevents a contact from being in the same journey twice at once. This flow is intentionally short and has no waits, so a contact leaves almost immediately after the alert sends. That means practically every deal_won event gets its own celebration.

Step 3: If/Else split — treat high‑value deals differently

Node: If/Else process

Next, add an If/Else node right after the trigger. This is your chance to highlight truly meaningful wins with different messaging.

You have two good options for the condition:

1. Based on a contact attribute (simpler):
   - Example: plan_tier is Agency OR plan_tier is Enterprise
   - These attributes would be set previously via Spreeflo.identify on the frontend or via the API when you update the customer’s profile.

2. Based on event history (more precise):
   - Use the Custom Events category in the segment builder and create a rule like:
   - Custom event deal_won triggered at least 1 time over all time
   - Where property mrr greater than 500
   - This says “treat them as high‑value if they’ve ever closed a deal worth $500+ MRR.”

For most SEO SaaS teams, the first option (plan tier) is enough: agencies and large teams go one way, everyone else goes the other.

Configure the If/Else:

• Condition: “Contact attribute plan_tier is Agency OR Enterprise”

• Then branch: “High value”

• Else branch: “Standard”

Every contact entering from deal_won will now go down one of these two paths.

Why branch at all for an internal alert?

Because you talk about a $1,500/mo agency account differently from a $49/mo content team:

• You might shout out the sales owner or founder by name.

• You might include more deal context for support and product.

• You might send the alert to a different internal list.

The If/Else makes that easy without duplicating whole journeys.

Step 4: Send Internal Email — the actual celebration

Node: Send Internal Email (one per branch)

On each branch, add a Send Internal Email action.

You’ll configure two templates:

1. High‑value template
   - Subject: “New agency deal: {{contact.company}} on {{contact.plan_tier}}”
   - Body idea:
   - Customer name, MRR, plan, billing period
   - Who closed it (from an attribute like sales_owner)
   - Any relevant feature tags (“Rank tracking + content briefs”)
   - Links into your app or admin panel

2. Standard template
   - Subject: “New customer: {{contact.company}} on {{contact.plan_tier}}”
   - Body: same structure, slightly lighter tone

Configuration details:

• From (email account): pick a shared sender like founder@ or alerts@.

• Recipients: choose your internal list or alias in the email template itself.

• Send only once: you can safely leave this on. Since each alert is about a specific deal_won run, the same contact won’t hit the exact same node twice in one run.

Why use Send Internal Email instead of marketing emails or webhooks only?

• It uses the same email builder and personalization as your marketing emails, but is explicitly internal.

• You can reference all contact attributes directly in the body, so team members see meaningful context without opening other tools.

• You don’t need to burn your “marketing emails” quota on internal comms.

Each branch then ends (no further nodes), or optionally flows into a shared Merge node if you want to add something later (like tagging).

Crucially, each path has exactly one Send Internal Email. There are no back‑to‑back sends, so you never spam your own team.

Optional: Tagging and external hooks for richer ops

The basic pattern above is enough to wake your team up to wins. But once you have it running, there are two small upgrades worth considering.

1. Add Tag — mark contacts who’ve generated revenue

After each Send Internal Email, you can add an Add Tag action:

• High‑value path: add tags like paying_customer and high_value

• Standard path: add paying_customer

Later, those tags become building blocks for other journeys:

• Trigger a customer‑only newsletter.

• Run win‑back campaigns differently for past payers.

• Use a Join Segment trigger that watches a “High‑value customers” segment.

Tags are cheap, flexible metadata. The getting started with tags guide is a good reference if you’re new to structuring them.

2. Webhook — pipe wins into Slack or your CRM

If you’re on Professional, drop a Webhook node after the internal email to fan the alert out to other systems:

• Webhook URL: your integration endpoint or a Zapier/Make hook

• Method: POST

• Contact fields: all contact attributes, or just the few you need

• Auth: Bearer token or API key if your endpoint requires it

Common uses:

• Post a celebratory message in a public Slack channel.

• Create or update a “Customer” or “Deal” record in your CRM.

• Trigger a downstream automation in another tool.

Webhook sits alongside the internal email; it doesn’t replace it. The email keeps your team informed even if a Slack bot breaks or an integration changes.

How this ties back to leverage for SEO SaaS founders

On paper, this journey is tiny: one trigger, one split, two internal emails, optional tag and webhook.

In practice, it changes how your small team experiences growth:

• Support sees new customers right as they join, not weeks later when the invoice report comes out.

• Product connects roadmaps to the kinds of accounts that are actually closing.

• The whole team gets a steady drip of “we shipped, we sold, it mattered” — critical if you’re fully remote.

And you, as founder, get to stop being the manual router of every good thing that happens.

Instead of thinking “I should tell the team about this” during a context switch, you know the system already did. That’s pure leverage: a one‑time setup that keeps paying emotional and operational dividends.

From Spreeflo’s side, this is exactly the kind of job the platform exists for:

• A Custom Event trigger wired through the Spreeflo API

• Simple routing logic in the visual journey editor

• Internal email templates using the same engine as your marketing messages

You don’t need a whole marketing team to make this happen. Just an hour, a backend endpoint, and the discipline to send one clean deal_won event.

Adapting the pattern to your own SEO SaaS

A few variations worth considering as you implement:

• Multiple products: If you sell rank tracking and content briefs as separate SKUs, include a product property on deal_won and either:
  - Add property conditions on the Custom Event trigger to create one journey per product, or
  - Use a Multi‑way Split on a product contact attribute to send different internal emails depending on which product closed.

• Trials vs paid: If you treat a “trial started” as a mini‑win, create a second journey with a trial_started event feeding into a lighter internal email. Keep deal_won for actual revenue.

• Annual upgrades: If you care more about annual conversions, add a property filter on your Custom Event trigger to only fire when billing_period is annual.

In each case, the skeleton is the same: backend event → Custom Event trigger → a bit of logic → Send Internal Email.

The quiet compounding effect

Most SEO SaaS founders obsess over dashboards: MRR charts, churn cohorts, organic traffic curves. Those matter. But your team’s day‑to‑day motivation comes from far more granular feedback: “Someone just paid us because of the thing I worked on.”

Automating a won‑deal celebration alert is a tiny workflow that quietly compounds:

• It keeps everyone emotionally close to the customer, even as you grow.

• It surfaces patterns (“wow, a lot of agencies have upgraded right after we shipped that new reporting feature”).

• It frees you from being the central notification system, so you can focus on higher‑leverage work.

If you’re already running Spreeflo for customer emails, this is an easy add. If you’re not, it’s the kind of low‑risk, high‑signal automation that justifies trying it: a free account gets you journey tooling you can start experimenting with, and you only pay when you’re ready to run full marketing sequences at scale.

Either way, the next time Stripe pings, your team should feel it too — automatically.