Building a State-Aware Evergreen Nurture System

Introduction

Onboarding is usually treated like a sequence with a start and an end. A user signs up, receives a handful of emails, and then falls into the general marketing calendar.

That model breaks down when the customer's actual progress does not match the campaign timeline.

At Zendrop, many users needed education long after the welcome sequence. Some had not connected a store. Some had not imported products. Some had not joined Zendrop Academy. Some had completed one milestone but not the next.

The problem was not a lack of content. The problem was that the nurture system needed to adapt to customer state.

This case study explains how I designed an evergreen nurture system that kept educating users while dynamically reinforcing the product behaviors that still mattered for each person.

Business Problem

After onboarding, users often entered generic marketing campaigns.

That created a lifecycle gap. The welcome flow could push users toward early actions, but after that the program became less aware of what the customer had actually done. A user who had not connected a store might receive the same nurture content as someone who had already imported products and explored Zendrop Academy.

Generic nurture fails for a simple reason: it assumes time equals progress.

In reality, a user can be on day 21 and still be stuck on the first meaningful action. Another user can complete multiple milestones on day one. A useful lifecycle system needs to account for both.

The objective was to build an always-on nurture program that did two jobs at once:

• Teach users how to build and operate a dropshipping business.
• Keep pointing each user toward the most important incomplete product behavior.

Why Native Platform Features Weren't Enough

The default way to solve this problem is to create multiple nurture versions.

One version for users who have not connected a store. Another for users who have not imported products. Another for users who have not joined Academy. Another for users who have done all three.

That approach creates workflow bloat fast.

The team ends up maintaining several versions of the same campaign, each with small CTA differences. Every new educational email becomes a branching problem. Every new product milestone adds another layer of complexity.

Zendrop needed a cleaner architecture:

• One evergreen education track.
• Conditional CTA blocks inside that track.
• Behavioral attributes deciding which action appeared.
• Engagement monitoring throughout the sequence.
• Branching only when the customer state truly required it.

The logic belonged inside the lifecycle system, not in a pile of duplicated campaign versions.

Solution Architecture

The nurture architecture had two layers: stable education and dynamic action.

The stable layer taught evergreen concepts: product selection, store setup, fulfillment, customer experience, Zendrop Academy, and practical ecommerce execution.

The dynamic layer changed the call to action based on user state.

Evergreen nurture email
  |
  +-- Educational body
  |
  +-- Dynamic CTA block
        |
        +-- Store not connected -> Connect store
        +-- Product not imported -> Import product
        +-- Academy not joined -> Join Academy
        +-- Milestones complete -> Next-stage action

This made the content feel relevant without forcing the team to rebuild the full sequence for every customer group.

The system could keep sending useful education while still asking the correct next question:

What is the most important incomplete behavior for this customer right now?

Technical Implementation

The implementation depended on a small set of product-state attributes.

store_connected: true | false
product_imported: true | false
academy_joined: true | false
last_engaged_at: timestamp
plan_status: free | trial | paid | canceled
experience_level: beginner | tried_before | experienced

Each evergreen email rendered a CTA block using conditional logic.

if store_connected == false:
  render "Connect your store" CTA
else if product_imported == false:
  render "Import your first product" CTA
else if academy_joined == false:
  render "Join Zendrop Academy" CTA
else:
  render next-stage CTA

That conditional block could appear beneath different educational topics.

For example, an email about product selection could still show a store-connection CTA if the user had not connected a store yet. That mattered because store connection was still the gating issue. The content could teach one concept while the system pointed the user toward the next required action.

The workflow also monitored engagement.

send nurture email
wait
check engagement
check milestone completion

if milestone completed:
  suppress old CTA
  move user forward

if no engagement:
  reduce frequency or enter re-engagement path

if active and incomplete:
  continue with dynamic CTA reinforcement

The result behaved more like adaptive lifecycle infrastructure than a traditional nurture campaign.

Engineering Decisions and Tradeoffs

The main decision was to put conditional logic inside reusable content rather than creating more workflow branches.

That kept the system smaller and easier to maintain. The tradeoff was that QA became more important. A dynamic CTA system needs testing across user states:

• No milestones complete.
• Store connected only.
• Store connected and product imported.
• All milestones complete.
• Free, trial, paid, and canceled plan states.
• Beginner and experienced users.

The second decision was to keep the educational content evergreen. This reduced production burden and made the sequence useful outside a single campaign window.

The third decision was to let customer behavior override calendar timing. A user should stop seeing a Connect Store CTA after connecting a store, even if they are only halfway through the nurture series.

Why This Scaled Better

A duplicated-campaign model grows linearly with every new audience and milestone. An adaptive-content model scales around state.

Duplicated model:
3 milestones x 4 audiences x 8 emails = many campaign variants

State-aware model:
1 nurture track + conditional CTA logic + product attributes

That does not remove complexity. It moves complexity into a cleaner layer.

The system still needs accurate attributes, clear fallback logic, and QA. But the ongoing burden is lower because the team can add educational content without rebuilding the entire lifecycle map.

Lessons Learned

Evergreen nurture works when it respects where the customer actually is.

The most important piece is not the newsletter topic or the campaign theme. It is the state evaluation that happens before the call to action appears.

If a user has not connected a store, the system should know that. If they already imported products, the system should stop acting like they have not. If they joined Academy, the next ask should move forward.

Closing Thoughts

Zendrop's evergreen nurture system was built around a simple idea: users do not progress on the same timeline.

The architecture let education stay consistent while action blocks changed based on customer behavior. That made the program more relevant without turning the workflow builder into a maze.

The point was not to build a bigger nurture sequence. It was to build one that could keep asking the right next question.