Never Miss a Whale: Automating CSM Kickoff for High-Value Shopify Merchants

The email hit the shared “success@” inbox at 3:07 a.m.

A seven-figure Shopify brand had just installed CartWizard, picked the $399/month plan, and accepted billing. By the time anyone on the team noticed (late the next afternoon), the merchant had already sent a frustrated ticket: “We installed yesterday. Is there someone we can talk to about rollout?”

For a small e‑commerce app team, that’s the nightmare. You work hard to win big accounts, then their first human touch is a support ticket instead of a proactive kickoff.

The sequence at the top of this page is the whole journey, end to end. It exists to fix exactly that moment: as soon as a contract crosses your “high-touch” threshold, a fully loaded internal kickoff email lands with your CSM (or founder) with the account’s profile, goals, and use cases, and a quiet failsafe watches to make sure the kickoff actually happens.

Let’s put a face to it.

CartWizard (fictional, but very typical) is a four-person team building a cart recovery app for Shopify stores. About 2,000 merchants pay between $49 and $399/month; anything over $250 gets high-touch onboarding. Before this journey, time-to-first-CSM-call for those larger stores averaged 3–5 days and depended entirely on whether someone remembered to check Stripe and the Shopify Partner dashboard. After implementing this flow in Spreeflo, that dropped under 24 hours without adding any headcount.

This playbook shows how to build that same safety net in your own account using Spreeflo’s campaign and journey automation, and how to adapt the pattern to your own app.

What this journey is doing behind the scenes

Before we go node by node, zoom out on the intent.

The journey does four things:

1. Listens for a high-value subscription event from your app.

2. Flags the contact as “high-touch” for the rest of their lifecycle.

3. Sends an internal kickoff brief with all the context your CSM needs.

4. Watches for a completed kickoff and escalates if the call doesn’t happen.

You wire it up once, and every future “whale” account automatically gets the right human attention. This is Brand Message #2 in action: founder-led businesses win on leverage, not headcount. You’re replacing a coordinator’s job with a 24/7 system.

Now let’s walk through the sequence at the top of the page, node by node.

1. Trigger on the exact moment money becomes real

Everything starts with a Custom Event trigger.

In your app, you already know when a store becomes “real revenue”:

• Shopify billing is accepted.

• A subscription is created or upgraded in your backend.

• A contract is signed for an enterprise tier.

In Spreeflo, you send that moment in as a custom event through the Spreeflo API or the JavaScript SDK. Think of events like subscription_activated or plan_upgraded, with properties such as:

• contract_value or mrr

• plan_name

• store_url

• store_size (maybe “SMB”, “mid-market”, “plus”)

The Custom Event trigger in the journey is configured roughly as:

• Event name: your production event, e.g. subscription_activated.

• Property condition: contract_value greater than or equal to your “high-touch” threshold (e.g. >= 250).

Re-enrollment:

• Turn this on if you want the journey to fire again when an existing customer upgrades above the threshold or makes a big expansion.

• Leave it off if you only want one kickoff per account, ever.

Why this choice matters:

• Putting the contract filter on the trigger (rather than in a later If/Else) means low-value installs never even enter this journey. You don’t spam your team with noise.

• Using a Custom Event instead of an import or manual tag means this reacts in seconds, not days. Time-to-CSM-call is now bounded by how quickly your app sends the event.

If you don’t already send contract size as an event property, this is the first change to make in your backend. Without that, you can’t reliably separate whales from everyone else.

2. Tag the account as high-touch for the long term

Next in the sequence: an Add Tag action.

Here you apply something like csm-high-touch or contract-250-plus to the contact:

• Node: Add Tag

• Tags: csm-high-touch (and optionally the plan, like plan-pro, if you prefer tags over attributes)

• “Force tag trigger”: usually off for this use case, because you’re not trying to kick off other journeys from this tag.

This tag does a few things:

• Makes it trivial to build a saved segment of high-touch accounts later using the segment builder.

• Lets you filter dashboards, cohorts, or web analytics views to “only high-touch” when you’re reviewing performance.

• Gives you a simple on/off flag you can use in other journeys: renewals, QBR reminders, upsell campaigns.

Could you rely only on contract_value as an attribute instead of tagging? Yes. Tags shine when you want to treat “high-touch” as a conceptual status that might change, or when non-technical teammates are browsing the contact record. They read a tag much faster than a numeric threshold.

The important part is that, from this step onward, high-value accounts carry a permanent marker that your entire automation system can respond to.

3. Send the internal kickoff brief your CSM actually wants

With the account tagged, the journey immediately sends the internal handoff.

Node: Send Internal Email

Configuration:

• Recipient: a team inbox like success@yourapp.com or a distribution list for CSMs.

• Template: built in the same editor you use for customer-facing email. The email builder makes this straightforward.

• “Send only once”: keep this on so the same high-touch account doesn’t accidentally spam the team if the trigger re-fires.

What goes into this email is the difference between noise and gold. At minimum:

• Store name and URL

• Contract value / plan

• Vertical (e.g. fashion, supplements, home goods)

• Primary goal (if you collect it on signup)

• Key use case(s)

• App usage so far (if you have at least one feature_used event)

All of these should already be stored on the contact as attributes. You might be sending them from your app’s signup form with a call to Spreeflo.identify, or syncing them from your user database via the Spreeflo API.

That means your internal email can read like:

New high-value merchant: $399/mo
Store: GreenPeak Outdoors (greenpeakoutdoors.com)
Vertical: Outdoor gear
Goal: Increase recovered revenue from abandoned carts
Use case: Multi-language recovery sequences for EU markets
First actions: Installed yesterday, created 2 recovery flows, no email templates customized yet

The point is to answer the questions your CSM would go hunting for before a call. No more alt-tabbing through Stripe, the Shopify Partner dashboard, your internal admin, and Intercom transcripts. It’s all in their inbox.

This is where Spreeflo’s “founder-led businesses win on leverage, not headcount” idea gets real. You didn’t hire a coordinator to compile this once a day. You wired data into automation and let it do the job, every night, without fail.

4. Give the CSM a reasonable window before escalating

If the journey stopped after that email, you’d already be in a better place. But you can go one level deeper: make sure the kickoff actually happens.

Two nodes handle this:

1. A Time Delay

2. A Wait Condition plus an If/Else split

First, the Time Delay:

• Node: Time Delay

• Configuration: 2 days, or whatever your realistic SLA is for first-touch on high-value accounts.

This is just breathing room. It lets your CSM respond, schedule, and run the kickoff without being nagged by automation right away.

After the delay, you add a Wait Condition:

• Condition: a custom event like csm_kickoff_completed triggered at least 1 time in the last 7 days for this contact.

• Timeout: for example, 3 days.

You’d fire csm_kickoff_completed from your internal tooling, calendar integration, or admin panel whenever the kickoff call is done. That could be as simple as a button your CSM clicks after a call, which then hits the Spreeflo API with that event.

The Wait Condition does two things:

• If the kickoff event arrives quickly (say, the same day), the contact moves on as soon as the condition is satisfied.

• If it doesn’t, the journey waits up to your timeout (3 days in this example) before moving on anyway.

On its own, Wait Condition doesn’t branch, so the next step is an If/Else process node.

Configuration for the If/Else:

• Condition: the same logical check as the Wait Condition: csm_kickoff_completed has happened at least once in the last 7 days.

• “Then” branch: accounts where the kickoff is done.

• “Else” branch: accounts where your SLA is now slipping.

You’ve now got two clean paths for automation to react differently.

5. Mark successful kickoffs and alert on dropped balls

On the “then” side of that If/Else, we keep it simple:

• Node: Add Tag

• Tag: csm-kickoff-complete

• Journey ends here for this branch.

That tag is powerful later. You can build a segment of “high-touch, kickoff complete, 90+ days on app” and target them with expansion campaigns, or pull them into a quarterly business review sequence. The segment builder makes “has tag X and doesn’t have tag Y” conditions trivial to express.

On the “else” side, it’s time for a quiet escalation.

Node: Send Internal Email

• Recipient: either the same CSM inbox or a team lead if you want stronger accountability.

• Subject: “Kickoff overdue: [Store Name] – [Contract Value]”

• Body: include when the high-value event fired, what plan they’re on, and a reminder of your SLA.

You’re not punishing anyone; you’re just making it very hard for a whale to slip silently into churn territory because the kickoff never happened.

Notice the pacing:

• The first internal email goes out immediately when the contract crosses the threshold.

• The second only fires if, after several days and a missed SLA, there’s still no kickoff event recorded.

No one is getting spammed, but you have a systemic way to surface risk.

Making the content of the kickoff email worth reading

All of this automation is only as good as the context you feed into that first internal email.

Two practical tips for e‑commerce apps:

1. Capture goals and use cases at install time

2. Standardize your CSM briefing layout

Instead of the usual “What’s your store URL?” form, add two free-text questions:

• “What are you hoping to improve with [Your App] in the next 90 days?”

• “Which workflows do you care about most? (e.g. cart recovery, post-purchase upsell, A/B testing, etc.)”

Store those answers as contact attributes through your SDK or via identify calls. Then pull them directly into the internal email template.

Use a consistent structure in the Send Internal Email template:

• “Profile” block (store size, country, vertical)

• “Contract” block (plan, MRR, billing start date)

• “Goals” block (verbatim from signup, lightly cleaned if needed)

• “Usage so far” block (count of key custom events: feature_used, campaign_launched, etc.)

You can build this once in the email builder and have every CSM briefing follow the same pattern. That makes preparation faster and call quality more consistent.

Once those pieces are in place, automation is doing work a human would struggle to keep up with: assembling a dossier the moment a contract is signed.

Why this journey earns its place in your stack

From a metrics point of view, this pattern feeds two lines in your dashboard:

• Time-to-CSM-call: you should see the median drop sharply once this is live, especially across your top quartile of contract values.

• Expansion rate at 90 days: high-touch accounts who got a timely, well-prepped kickoff call are far more likely to expand. You can track that by segmenting on csm-kickoff-complete and contract value.

From an operations point of view, you’ve taken what is normally a fragile, human-remembered workflow and wired it into a journey that never gets tired. You did it without hiring a coordinator or buying an enterprise CS platform.

That’s the theme running through this entire pattern: founder-led businesses win on leverage, not headcount.

Spreeflo’s campaign and journey tooling gives you the same kind of internal workflows that bigger competitors buy with expensive stacks, but in a way a two‑to‑ten‑person team can actually set up and maintain.

Wire this journey once. Let it quietly watch your installs, wake your CSMs up for the important ones, and keep an eye on whether the kickoff really happened. Then go back to shipping product, knowing your whales no longer fall through the cracks.