Stop Recycling the Same Drip: Build an Evergreen Multi‑Stream Nurture for Your Shopify App

The CartWizard team thought they’d nailed onboarding.

They had a tidy 7‑email trial sequence: day-one setup guide, case study on day three, pricing FAQ on day five, and a last‑chance discount at the end. It did fine at first. Then installs kept climbing, trial‑to‑paid plateaued, and churn from month one never moved.

Looking at the numbers, a pattern emerged: merchants who’d been around for months were still getting “day-three trial” content. Power users, window‑shoppers, and at‑risk accounts were all shoved through the same linear drip. Once someone reached the end, communication went quiet until a promo blast.

That’s the lifecycle leak: you invest a lot to win attention from the Shopify App Store, then waste it by sending the same short series to everyone.

The sequence at the top of this page is the alternative: an always‑on, multi‑stream education program. Instead of one drip, you run several streams in parallel and move contacts between them as their lifecycle stage and behavior change. Content never “runs out,” and every merchant feels like you’re talking to where they are today, not where they were on install day.

This playbook walks through that journey, node by node, and shows how to rebuild your nurture so it compounds MRR instead of capping it.

Why a single drip goes stale for Shopify apps

Shopify app lifecycles are messy:

• Some merchants install your app, try a feature once, and disappear.

• Others binge it the first weekend, then let it idle for three weeks.

• A few become power users who want every advanced tactic you have.

When you send the same fixed series to all of them, three things happen:

1. Content relevance decays fast. By email four, half your list is either ahead of, or behind, the message.

2. There’s no long‑term plan. When the series ends, so does systematic education. Everything after that is ad hoc.

3. You can’t meaningfully compare streams. Is your “trial” track good? Is your “expansion” messaging better? Hard to say if there’s only one track.

Most SaaS teams know they should segment by lifecycle stage. What they miss is that those stages are dynamic. A merchant can move from “evaluating” to “adopting” or “at‑risk” in a single week.

The only sane way to keep up is to treat nurture as a set of rotating streams, not a one‑way road.

What this always‑on system actually does

In the example journey, we assume an app like CartWizard: cart recovery and upsell for Shopify stores, $49/month, most installs coming from the App Store search results.

The journey models three primary education streams:

• Evaluate: new trials and new installs deciding whether to keep you.

• Adopt: new paying customers who need to wire you into their daily workflow.

• Expand: healthy users who are ready for advanced features, new use cases, and upsells.

Contacts enter the program when they qualify (for example, they installed the app and are subscribed to marketing). From there:

• A Criteria Match trigger enrolls them and sets their starting stream.

• A Cyclic trigger runs daily, finds everyone currently in the education program, and sends them the next relevant lesson for their stream.

• Multi-way Split and Update Contact Attribute nodes track which lesson they’re on and when they’ve completed a stream, then move them to the next one.

You build the system once. As long as your content stays fresh, it can run indefinitely, rotating merchants through whatever stream matches their current reality.

This is the core of message 1 and 3 from the Spreeflo brand: capture detail on every customer so you can speak to each uniquely, and stop leaking lifetime value by letting engagement fizzle out after a short drip.

Let’s break the journey down.

Step 1: Define the data model for your streams

Before you touch the canvas, decide how you’ll encode “where someone is” on the contact record.

You’ll use a mix of contact attributes and tags, managed through Spreeflo’s audiences and the segment builder.

A simple pattern for this journey:

• Text attribute: education_stage
  Values: "evaluate", "adopt", "expand". This is the main stream switch.

• Number attributes:
  evaluate_index, adopt_index, expand_index
  These track which lesson a contact has already received in each stream (0, 1, 2, 3…).

• Timestamp attributes (optional but powerful):
  evaluate_started_at, evaluate_completed_at, adopt_started_at, etc.
  These let you measure stream completion and time‑to‑complete with the Segment Builder.

• Number attribute (optional): engagement_score
  Increment when a contact clicks or replies to key emails, using a separate scoring journey.

• Tags:
  - education_program – indicates the contact is part of the evergreen nurture.
  - stage_evaluate, stage_adopt, stage_expand – make it easy to query or report by stage.

You can create these attributes in your contact schema, then update them inside the journey with Update Contact Attribute and Add Tag nodes. If you’re not using tags yet, the getting started with tags guide has a quick overview.

This data model is what lets a small team send different content to merchants who look identical in Shopify but behave very differently in your app.

Step 2: Enroll the right merchants with a Criteria Match trigger

The first trigger in the journey is Criteria Match. Its job is to say, “This merchant should be in the education program at all.”

Configure the Criteria Match trigger like this:

• Re-enrollment: off. You want a contact to pass through this “setup” path only once.

• Criteria: use the segment builder to define something like:
  - Email Subscription Status is "Subscribed"
  - Marketing Status is "Marketing"
  - Custom event "app_installed" triggered at least 1 time in the last 7 days
  - Not member of a segment like "Do not nurture"

Any time a merchant newly matches that definition, they enter the journey on this branch.

Immediately after the trigger, the journey runs three actions in sequence:

1. Add Tag – apply education_program and stage_evaluate.
   This makes them eligible for the daily Cyclic trigger and gives you a quick way to filter “everyone in the program” later.

2. Update Contact Attribute – set education_stage to "evaluate" and initialize your indices: evaluate_index = 0, adopt_index = 0, expand_index = 0.
   These are static literals entered in the node; you’re saying “start them at the first lesson in each stream.”

3. Send Email – a short “Welcome to CartWizard education” message.
   Use the email builder to set expectations: how often they’ll hear from you, what kind of content, and how to opt down without opting out entirely. Keep the Send only once toggle on so re‑entries (if you ever turn re‑enrollment on) can’t resend this.

After that welcome, this branch simply ends. The heavy lifting happens in the second trigger.

Step 3: Run the program daily with a Cyclic trigger

The second trigger is a Cyclic trigger that powers the “always‑on” part of the system.

Configure it roughly like this:

• Re-enrollment: on. Contacts should be processed every time the schedule ticks, as long as they match the criteria and aren’t mid‑journey.

• Repeat interval: every 1 day.

• Time of day: something sane for your audience, e.g., 09:15 in your primary timezone.

• Criteria: contacts who
  - Have the tag education_program
  - Have Email Subscription Status "Subscribed"
  - Are marked Marketing

This Cyclic trigger is a separate entry point in the same journey. Because the earlier Criteria Match path is short (no long waits), contacts exit quickly and are ready to be re‑enrolled by the Cyclic trigger on the next daily tick.

The output of the Cyclic trigger flows directly into a Multi-way Split that decides which stream they should get content from today.

Step 4: Route each contact to the right stream

The first process node after the Cyclic trigger is a Multi-way Split named “Choose current education stage”.

You’ll create one branch per stream, each with its own condition:

• Branch “Evaluate”: education_stage equals "evaluate".

• Branch “Adopt”: education_stage equals "adopt".

• Branch “Expand”: education_stage equals "expand".

Else branch: for safety, catch anything that doesn’t match and, for now, just Add Tag education_needs_triage and end. (This usually only happens if someone’s attributes are half‑migrated or manually edited.)

Most contacts will hit one of the three named branches. From here, each stream branch uses another Multi-way Split plus a set of Send Email and Update Contact Attribute nodes to send one lesson and update that stream’s index.

We’ll walk the Evaluate stream in detail; Adopt and Expand follow the same pattern.

Step 5: Inside a stream, pick the next lesson

Let’s say your Evaluate stream has three core lessons for new trials:

1. Setup and first recovery campaign.

2. Proof that it works (results from other merchants).

3. Handling common objections (fees, ROI, edge cases).

In the Evaluate branch, add a second Multi-way Split named “Evaluate: next lesson”. Its conditions look at evaluate_index:

• Branch “Eval 1”: evaluate_index is blank or equals 0.

• Branch “Eval 2”: evaluate_index equals 1.

• Branch “Eval 3”: evaluate_index equals 2.

• Else branch “Eval complete”: anything else.

Each of the first three branches sends one email, then updates the index:

• Eval 1 branch
  - Send Email: “Get your first recovery campaign live in 10 minutes”.
  - Update Contact Attribute: set evaluate_index to 1.

• Eval 2 branch
  - Send Email: case studies from similar merchants, with clear numbers.
  - Update Contact Attribute: set evaluate_index to 2.

• Eval 3 branch
  - Send Email: pricing and objection‑handling content, framed around value.
  - Update Contact Attribute: set evaluate_index to 3.

Every branch ends after the Update Contact Attribute node. That’s deliberate: on any given day, a contact receives at most one nurture email from this journey.

On the next daily Cyclic tick, they enter again, hit the “Choose current education stage” split (still evaluate), and the “Evaluate: next lesson” split sends them to the next branch based on their updated index.

When a contact completes a stream

The else branch “Eval complete” handles anyone whose evaluate_index is 3 or higher.

Here, you don’t send another lesson email. Instead, you:

1. Update Contact Attribute – set education_stage to "adopt".

2. Update Contact Attribute – set adopt_index to 0.

3. Update Contact Attribute – set evaluate_completed_at to now (Timestamp with “Set to now”).

4. Add Tag – remove stage_evaluate (using Remove Tag) and add stage_adopt.

Optionally, you can also send a short “You’re ready for the next playbook” email from a separate journey triggered by the tag change, so you don’t accidentally double‑send on the same day.

From the next Cyclic tick onward, this contact will flow into the Adopt branch instead of Evaluate.

The same pattern repeats inside the Adopt branch: a “next lesson” Multi‑way Split keyed off adopt_index, sending adoption content and, at completion, flipping education_stage to "expand" and initializing expand_index.

Step 6: Keep Expand stream evergreen

By the time a contact reaches Expand, they’ve proven they’re sticking around and engaging. This stream is where “content never runs out” matters most.

You have a couple of options:

• Long linear series: Treat it like Evaluate and Adopt, but with many more lessons (e.g., 10–15). Once expand_index exceeds your last lesson, keep it fixed and stop sending new emails. Use this if you’re worried about fatigue.

• Looping evergreen series: Once expand_index hits your max lesson number, set it back to 0 in the “complete” branch. Next time the Cyclic trigger runs, they’ll start at the top again. Because your Expand content is more like a rotating newsletter of advanced tactics and product updates, this can work well.

Either way, the implementation is identical: a Multi‑way Split on expand_index, a set of Send Email + Update Contact Attribute pairs, and a “complete” else branch that decides whether to loop or stop.

This structure makes it trivial to add or swap lessons over time. You can introduce a new Expand email 4 by:

1. Adding a new branch for expand_index = 3.

2. Updating your later indices as needed.

No need to rebuild the entire journey.

Step 7: Protect engagement and avoid over‑sending

Because the Cyclic trigger runs every day, pacing matters.

The design above adheres to a few guardrails:

• One nurture email per day, max. Each path from the Cyclic trigger through a stream has a single Send Email node and no email‑sending loops.

• Welcome email is separate. The Criteria Match path sends its own welcome before the daily cadence kicks in. That email is the only exception, and it runs at install time, not on a schedule.

If you want to slow things down for less engaged contacts, you can layer in an If/Else or Check Email Activity node before sending stream emails:

• After the Cyclic trigger, insert an If/Else: “Has opened any nurture email in the last 14 days?”.

• The “yes” branch proceeds to the Multi‑way Split and gets the next lesson.

• The “else” branch sends them to a gentler cadence or even pauses them by removing the education_program tag until they re‑engage via another action.

You can also build a separate small journey with an Email Action trigger that increments engagement_score every time someone opens or clicks key messages. That attribute then becomes another condition in your stage routing logic.

Step 8: Measure stream performance like a product

This pattern is about more than delivering emails. It’s about treating your nurture like a product feature that can be optimized.

With the attributes and tags you’ve set up, you can create segments such as:

• “Completed Evaluate stream” – evaluate_completed_at is not blank.

• “Stuck in Evaluate” – education_stage is "evaluate" and evaluate_index >= 2 and evaluate_completed_at is blank.

• “Expand power users” – education_stage is "expand" and engagement_score >= 30.

From there, three key metrics become easy to track:

1. Engagement score: average and distribution by stream. Are Evaluate contacts actually interacting, or are you overwhelming them?

2. Stream‑completion rate:
   - Evaluate completion = contacts with evaluate_completed_at set ÷ contacts with education_stage ever equal to "evaluate".
   - Same for Adopt and Expand.

3. MQL rate per stream: define your own MQL criteria (for example, “installed for 14+ days AND used core feature X AND engagement_score >= 20”), then measure how many MQLs originated in each stream. That tells you whether to invest more in trial education or in expansion content.

Because this is all built inside Spreeflo’s campaigns and journeys, you don’t need another analytics tool to understand which stream is doing the work. And with web tracking and analytics turned on, you can fold on‑site behavior (pricing page views, docs visits) into your criteria as well.

Adapting this to your app’s reality

Every Shopify app has its own versions of “evaluate, adopt, expand.”

For a reporting tool like ShopMetrics, streams might align to:

• Evaluate: connect data sources and ship first automated report.

• Adopt: customize dashboards and invite teammates.

• Expand: advanced attribution models, agency workflows, and upsell to higher tiers.

For a review app, streams could be:

• Evaluate: import existing reviews and show first on‑site widget.

• Adopt: automate review requests post‑purchase.

• Expand: syndication, SMS review requests, and seasonal campaigns.

The underlying journey is the same. The difference is in:

• Which custom events you send from your app into Spreeflo.

• How you define stream‑entry and completion conditions.

• What content sits behind each Send Email node.

As your content library grows, you just plug new lessons into the existing structure. No need to rethink the automation model every quarter.

The bigger payoff: compounding education for a small team

Founder‑led SaaS teams rarely have the time or headcount to run bespoke campaigns for each sliver of their customer base. That’s where this pattern earns its keep.

You put in the upfront thought:

• Capture enough detail on each merchant (events, tags, attributes) to know who they are and how they use your app.

• Map a few meaningful streams to that reality.

• Wire a single journey that reads those signals and sends the next right piece of content every day.

From there, the system just runs. You tweak copy, add lessons, and refine criteria, but the scaffolding stays stable. The result is fewer merchants slipping through the cracks after install, more of them reaching real activation, and a healthier base of power users primed for expansion offers.

Most Shopify apps are still stuck sending the same linear trial drip they wrote three years ago. If you treat nurture as an evergreen, multi‑stream product in its own right, you’ll quietly pull ahead on retention and lifetime value—without adding a single person to the team.