Plan-tier routing: how Shopify apps send one product update, three different ways

The day before a big release, Elena from “Checkout Pilot” did what most Shopify app founders do.

She drafted a single product-update email: new features, screenshots, a short changelog. She queued it up to go out to everyone: stores on the free plan, mid-market brands on $79/month, and a handful of high-ARPU agencies paying $299.

The result looked fine in aggregate. Open rate was “okay”. Clicks were “not bad”.

But when she pulled it apart by plan tier in her analytics, the story was ugly. Free users barely clicked, Pro stores complained the features felt “too basic”, and Enterprise accounts forwarded the email internally with confused replies: “Is this for us?”

The problem wasn’t the update. It was the blunt instrument.

The sequence at the top of this page is the whole campaign, end to end. It’s built to fix exactly this: one send, multiple paths, so Free, Pro, and Enterprise contacts each get an email that feels written for them.

We’ll walk through that sequence node by node in Spreeflo, using a fictional Shopify app called CartWizard:

• Cart abandonment and upsell app

• ~2,500 active customers, $120k MRR

• Plans: Free, Growth ($49), Scale ($149)

• Stack: Shopify, a custom Node backend, Stripe, and Spreeflo for email and journeys

CartWizard’s team wants every product update, launch, and “what’s new” touch to land differently for each tier. That’s what this pattern does.

Why one-size product updates quietly erode LTV

If you sell a subscription app into Shopify stores, your “Free” and “Enterprise” customers are not just different price points. They’re different businesses with different problems.

Free:

• Often early-stage stores

• Time-poor, budget-sensitive

• Not yet seeing consistent sales

Pro / Growth:

• Running real volume

• Thinking in terms of AOV, conversion rate, and ROAS

• Care about ROI more than raw feature count

Enterprise / Scale:

• Multi-store setups, agencies, aggregators

• Worried about reliability, support, and team workflows

Send them all the same product update and three things happen:

1. The message is always slightly wrong for someone.

2. You miss obvious upsell opportunities (“this feature unlocks fully on Pro+”).

3. Engagement metrics blur together. You can’t see which tier is actually excited.

Spreeflo’s core belief is that you should capture detail on every customer so you can speak to each of them uniquely. Plan tier is one of the highest-signal details you have. Plan-tier routing is how you actually use it.

The pattern in one picture: a Multi-way Split on plan

Before we zoom into the nodes, let’s describe what you’re seeing in the sequence at the top of this page.

At a high level:

1. You start a Campaign that targets “all active customers” in your audience.

2. The first node in the canvas is a Multi-way Split that branches contacts by plan tier: Branch 1: Free Branch 2: Pro (or Growth) Branch 3: Enterprise (or Scale) Else branch: everyone whose plan is missing or doesn’t match those options

3. Down each branch is a Send Email node with tier-specific copy, subject line, and CTA.

4. Each branch then runs through an Add Tag node so you can segment later by “saw this update as Free / Pro / Enterprise”.

5. A Merge node pulls everyone back together, and the campaign ends.

One send. Four paths. Each contact gets exactly one email, but the framing, examples, and upsell logic are tailored to their plan.

If you’re new to the editor in Spreeflo, the overview of campaigns and journeys is worth a quick skim. What matters here: this is a Campaign, not a Journey. You pick the audience once, run it, and it’s done.

Step 0: Make “plan” a real contact attribute, not an afterthought

Plan-tier routing depends on Spreeflo actually knowing each contact’s plan.

For CartWizard, that means they have a plan_tier contact attribute with values like "Free", "Growth", and "Scale" synced from their backend.

There are a few common ways to keep that attribute current:

• On your server, call the Spreeflo API whenever a customer upgrades, downgrades, or cancels, setting plan_tier on the contact.

• When you import contacts from Stripe or your database, map the plan column onto a custom attribute in the import wizard (see the Audiences overview under audiences and contact attributes).

• As a fallback, you can edit contacts in the UI, but manual updates don’t scale past a handful of accounts.

Once plan_tier exists and is reasonably accurate, everything else in this pattern becomes simple. The Multi-way Split node reads this attribute and routes contacts accordingly, using the same criteria UI as the segment builder.

Step 1: Campaign Start – define who should even be in this send

In the canvas, the first node is Campaign Start (CAMPAIGN_START). The real targeting happens on the campaign’s audience step, before you arrive in the editor.

For CartWizard’s product update, they:

• Include: all contacts with Email Subscription Status = Subscribed

• Exclude: churned customers, trial users who never converted, internal test accounts

You could express some of that logic in an If/Else later, but pushing it into the audience filter keeps the sequence cleaner and ensures only real customers hit the Multi-way Split.

If CartWizard later wants a “what’s new” sequence that runs automatically whenever someone upgrades, that’s when a Journey with Join Segment or Criteria Match triggers makes sense. For the one-off broadcast, a Campaign is the right tool.

Step 2: Multi-way Split on plan_tier – the heart of the pattern

Immediately after Campaign Start, the next node is Multi-way Split.

Configuration:

• Branch “Free”: condition where contact attribute plan_tier is "Free".

• Branch “Pro”: plan_tier is "Growth" (CartWizard’s $49 plan).

• Branch “Enterprise”: plan_tier is "Scale".

• Else branch: no condition; it catches anyone missing a plan or on a legacy tier.

Behind the scenes, each branch’s condition uses the Segment Builder:

• Category: Contact Attributes

• Field: your plan_tier custom attribute

• Operator: is

• Value: the literal string for that plan

Order matters for Multi-way Split. Spreeflo evaluates branches from top to bottom and sends each contact down the first matching branch. For opaque or overlapping plan logic, that matters a lot. For simple tiers like this, Free → Pro → Enterprise → Else is intuitive and safe.

Why use Multi-way Split here instead of three separate campaigns?

• Operational simplicity: one asset to schedule, QA, and analyze.

• Shared logic: any pre- or post-steps (tags, waits, webhooks) live in one place.

• Less risk: you can’t accidentally send a Free email to Enterprise because the routing lives in one node, not in three slightly-different audience filters.

Step 3: Tier-specific Send Email nodes – one per branch

Each plan branch now gets its own Send Email node.

CartWizard names them clearly in the canvas:

• Email – Product update for Free

• Email – Product update for Growth

• Email – Product update for Scale

• Email – Product update (Other tiers)

For each node, they:

• Choose the same sender identity (e.g. “Elena from CartWizard <team@cartwizard.app>”).

• Toggle “Send only once” on, so contacts never accidentally get the same update twice.

• Either select an existing template created in the email builder, or build the content directly in the editor.

The strategy is different per tier:

Free:

• Emphasize what they can do with the new features on Free.

• Clearly point out what unlocks on paid plans with a soft upsell CTA (“Ready for automated A/B tests? That’s in Growth.”).

• Share one “quick win” case study from a similar small store.

Pro / Growth:

• Lead with outcomes: “Here’s how this makes you more money per session.”

• Use revenue-focused language (AOV, recovery rate, incremental orders).

• Position higher tiers as multipliers, not gates (“On Scale, you can roll this out across all storefronts.”).

Enterprise / Scale:

• Talk about team workflows, permissions, and reliability.

• Reference SLAs or dedicated support if you offer them.

• Invite them to forward to their team with language like “We built this for agencies running 10+ stores.”

Else branch:

• Keep it generic but useful.

• Add a short PS nudging them to check their billing page if they’re not sure which tier they’re on.

There’s a clear rule you’ll see throughout the canvas: there are no back-to-back Send Email nodes on any path. If you ever want a follow-up email after this one, insert at least a Time Delay or Wait Condition between them to avoid spammy bursts.

Step 4: Tagging who saw what – Add Tag on every branch

Right after each Send Email, CartWizard drops an Add Tag node.

Example tags:

• update_q2_2026_free

• update_q2_2026_growth

• update_q2_2026_scale

• update_q2_2026_unknown

Configuration for each Add Tag node:

• Tags: the one specific to that branch.

• Force tag trigger: off (no need to fire Added Tag triggers from a Campaign).

Why bother tagging when email analytics already show opens and clicks per template?

Two reasons:

1. Longitudinal behavior. A tag lets you build a segment later like “all contacts who saw our Q2 2026 update as Free” and then ask: how many of them upgraded? How is their churn vs the rest?

2. Cross-campaign targeting. You can create a “didn’t see this update” segment for a later campaign, or a “saw this as Free, now on Pro” group for onboarding into newly unlocked features.

If you haven’t used tags much in Spreeflo yet, the primer on getting started with tags is a quick orientation. The key idea: tags are cheap, and future-you is always glad you added one more bit of context.

Step 5: Merge – bringing everyone back to one path

Each Add Tag node flows into a shared Merge node.

Merge has no configuration. Its only job is to collect multiple branches and continue as a single outgoing path.

For this basic plan-tier routing pattern, CartWizard doesn’t add more steps after the Merge. The campaign ends there. That’s enough to:

• Route every contact to the right tier email

• Mark who saw what for later analysis

If you wanted to get fancier, Merge is where you’d add downstream steps that apply to everyone, regardless of plan. Examples:

• A Webhook to post a summary into your internal Slack (Pro plan feature).

• A Time Delay plus a survey email asking “Which feature did you try?”.

• A Wait Condition for “custom event feature_used has triggered at least 1 time in the last 7 days” followed by different CTAs for adopters vs non-adopters.

The canvas stays clean because you only build those extras once, after the Merge, instead of repeating them under every branch.

Measuring what matters: per-tier engagement and adoption

One benefit of this pattern is obvious: the content feels more relevant. The other benefit shows up in your reporting.

Per-tier engagement

Because each branch uses its own Send Email template, you get separate analytics for:

• Open rate per tier

• Click-through rate per tier

• Reply rate, if you invite responses

CartWizard’s first tiered update showed:

• Free: 18% open, 2% click

• Growth: 34% open, 9% click

• Scale: 52% open, 19% click

Previously, they saw “29% open, 7% click” and called it a day. Now they know their highest-paying customers are actually more engaged than the headline number suggests, and that Free needs different subject-line and timing experiments.

Tier-specific adoption

Tags make it easy to build follow-up segments:

• “Saw update as Free, upgraded within 30 days”

• “Saw update as Growth, never used Feature X”

• “Saw update as Scale, reduced churn in the next quarter”

You can build those segments right inside Spreeflo using the segment builder, combining:

• Tag rules (who got which email)

• Custom Event rules (feature_used, subscription_upgraded, etc.)

• Email Activity rules (who clicked the “Enable now” link)

You don’t have to wire all of that into the initial campaign. Start simple: plan-tier emails plus tags. Then add more sophistication as you see which questions your data actually answers.

Adapting the pattern to journeys: automatic tier-aware onboarding

So far, we’ve talked about a one-time product update Campaign.

The same Multi-way Split pattern is just as useful in always-on Journeys:

• Welcome series that looks different for Free vs Pro installs

• Post-upgrade sequences that highlight unlocked features by tier

• Win-back flows that pitch a downgrade to at-risk high-tier users instead of a hard churn

The main differences when you convert this pattern to a Journey:

1. You replace Campaign Start with a trigger: Join Segment “Active customers” for ongoing updates, or Custom Event subscription_upgraded with plan_tier property conditions

2. You keep the Multi-way Split on plan_tier as the first process node.

3. You decide how re-enrollment should work on the trigger: If you want the journey to run every time someone changes plan, turn isReEnrollment on for the relevant trigger. That way a store can receive the Pro-specific path after upgrading and, later, the Enterprise-specific path if they move again. Remember that re-enrollment is journey-wide. Once a contact is currently inside the journey, no trigger will create a second parallel instance until they exit. For welcome / upgrade flows, that’s almost always what you want.

Everything else about the node-by-node logic can look almost identical: tiered Send Email nodes, Add Tag per branch, Merge.

Journeys are where this pattern delivers compounding value. You build it once and every new install, upgrade, or reactivation quietly gets the right version of your messaging without you touching it again.

The real win: treating “plan” as a story, not just a billing field

Most Shopify app teams already track plan tiers. It drives pricing, not marketing.

Plan-tier routing flips that. It takes a detail you already have and moves it into how you speak to customers:

• Free users hear about quick wins and the smallest next commitment.

• Pro users see how every feature connects to revenue and performance.

• Enterprise accounts feel like you’re thinking at their scale, not shouting from your changelog.

The mechanics in Spreeflo are straightforward: a Multi-way Split, a handful of tier-specific emails, and some tags. The payoff is ongoing: clearer signals in your engagement data, better-fitting upsell paths, and customers who feel like you’re talking to their context.

Founder-led apps win on leverage, not headcount. A pattern like this is the exact kind of system that works for you while you’re shipping the next release: set up once, route every contact to the right story, and let your messaging compound instead of flatten.

When you’re ready to stop sending the same product update to everyone, this is where to start.