Most teams see it as time-consuming, hard to measure, and almost impossible to make actually perform.

And let’s be honest, most lifecycle emails read like the terms and conditions in a bank email.

In this edition, I’ll show you how we built a 3-email sequence at lemlist that got +57% open rate and 18% click rate, using real user data, no fluff.

Here’s what we’ll cover:

• The tools I used (and simpler alternatives if you’re not as technical)

• How to use product data to write emails that feel 1:1

• What made this flow perform — and what you can steal for yours

1. The tool used to create the flow

To build a similar flow at scale, you’ll need tools that help you:

1. Access user behavior data

   → Check with your data or tech team for access to your data warehouse (we use BigQuery).

2. Process and transform that data

   → You’ll need something to pull, clean, and manipulate it. I use n8n, but Clay or Make can do the job too.

3. Send dynamic marketing emails

   → Your email platform must accept data from a webhook. I use Customer.io, but HubSpot, Brevo, or similar tools work as well.

2. How to build the flow

The logic is actually simple:

1. Trigger: You send user data from your product to n8n through your marketing tool.

2. Query: n8n runs an SQL query on your data warehouse using that user data.

3. Format: The results are cleaned and formatted so they’re ready for the LLM.

4. Generate: The LLM processes the data and returns personalized insights.

5. Send: You reformat the output (to fit payload limits) and push it back into Customer.io — so it can be used in emails as naturally as possible.

Let’s breakdown each of them:

1. The trigger part.

When a lead enters your marketing CRM, you’ll need to decide which ones you want to push.

This part is simple. You’ll create rules based on lead attributes such as job title, persona, or plan name.

From there, you’ll use a webhook to send this data to your n8n flow. Just make sure the data is formatted in JSON.

The data that you send will be used in the SQL request to retrieve the data from that user in your database.

2. The query to retrieve the data

Now that your lead’s data has reached n8n, it’s time to get the context you’ll need for the email.

Here’s what happens:

• The SQL node in n8n connects to your data source (it could be BigQuery, PostgreSQL, or any other database).

• It runs a short query to collect key information about the user or their team, things like recent activity, usage, or performance metrics.

Keep it light.

Only fetch what’s useful for your message. You don’t need every column from your dataset just a few key stats that will help you write something meaningful.

⚠️ Common mistakes to avoid:

• Pulling too much data → your flow becomes slow and unstable.

• Forgetting filters → you might end up sending wrong insights to the wrong people.

💡 Pro tip:

If you’re not sure what to pull, start small, for example: number of actions taken, time since last login, or feature most used.

That’s usually enough to create personalized content.

3. Generate the personalized insights.

Here’s the fun part.

Once you’ve got clean data, you want to turn it into short, readable insights that make sense for your user.

This is where code or AI nodes inside n8n do the magic.

• A Function node (or a Code node) cleans and prepares your data: it rounds numbers, renames fields, removes unnecessary stuff.

  → Example: “campaign_open_rate: 0.4312” becomes “Open rate: 43%.”

• Then, you can add an LLM node (like OpenAI or Claude) to generate short text based on that data.

  → Example output:

  “Your open rate is improving, but reply rate is still low. Try shortening your subject lines.”

You can ask the model to return the result in a clean JSON format, with 2–3 lines max.

This makes it easy to inject into your email later.

⚠️ Be careful with AI output:

• Always set a word or character limit.

• Avoid complex instructions.

• And always validate the output with a small Code node that checks if the response is well formatted (so the flow doesn’t break).

💡 If you don’t want to use AI, you can still use simple logic rules:

“If open rate < 30% → recommend improving subject lines.”

“If no activity in 7 days → suggest sending a reminder email.”

4. Send the data back to Customer.io

Once your message is ready, it’s time to send it back to your email platform.

• You’ll use an HTTP Request node to push the final insights back to Customer.io (or any other ESP you use).

• The message is usually sent as a few custom attributes, like:

  • summary_text → plain text version

  • summary_html → formatted version for the email

  • timestamp → date it was generated

These attributes will automatically appear inside Customer.io and can be used directly in your email templates.

💡 Example:

If your attribute is called summary_text, you can insert it into your email body using:

{{customer.summary_text}}

And that’s it, when the email is sent, your user receives a personalized message built entirely from their own data.

⚠️ Common mistakes to watch for:

• Sending attributes that are too long (Customer.io limits size). Keep text under 1,000 characters.

• Forgetting to test on dummy data first. Always try your flow with test users before going live.

Example of the final result

Here’s an example of what the output might look like once the data reaches Customer.io:

Once it’s there, all you need to do is drop it into your email template, and it’ll render beautifully.

Subscribe now

Common pitfalls & how to fix them

Even if this flow looks simple once you see it mapped out, a few small details can break things if you’re not careful. Here’s what usually goes wrong, and how to avoid it.

1. Messy or missing data

The problem: Your webhook sends inconsistent information, sometimes a missing email, sometimes a wrong team ID.

The fix:

• Ask your tech or data team to confirm which fields are always reliable.

• In n8n, add an “If” node right after the trigger. If the key data is missing, stop the flow or send a simple fallback message instead of breaking the automation.

2. Pulling too much data at once

The problem: You try to fetch a full user history instead of a small snapshot. The query takes forever, or n8n times out.

The fix:

• Limit your SQL query to the most recent activity or last 7 days.

• If you need more, break it into two smaller flows instead of one big one.

3. AI output is too long or too random

The problem: The model sometimes writes essays, or gives advice that doesn’t fit your use case.

The fix:

• Keep your prompt clear: “Write 3 short bullet points (max 20 words each). No emojis, no intros.”

• After the AI node, add a small Code node that checks if the output is valid JSON and under 1,000 characters.

4. Formatting breaks in Customer.io

The problem: The text looks weird once it appears in the email, strange spacing or HTML errors.

The fix:

• Always send two versions: one plain text, one HTML.

• In your HTML, use simple tags like <p> or <ul> only.

• Test with a few dummy users before launching to your real audience.

5. ESP limits or silent drops

The problem: You push too much data and Customer.io (or another ESP) silently cuts off your message.

The fix:

• Keep each attribute below 1,000 characters.

• Compress or shorten the text before sending.

• If you need to send longer content, link to a page inside your product instead of embedding everything.

6. Forgetting to log errors

The problem: A node fails, but you have no idea why and the flow just stops.

The fix:

• Add an Error Trigger node at the bottom of your flow.

• Make it send a short Slack or email alert to your team with the user ID and error message.

  That way, you can fix problems before they affect real users.

7. Making changes directly on the live flow

The problem: You edit while it’s running and accidentally break production.

The fix:

• Clone your flow in n8n.

• Test the new version on a “sandbox” workspace or fake user data before deploying.

💡 Final tip:

Always start small. Get one user journey working perfectly, one event, one query, one insight.

Once it runs smoothly, you can duplicate it for other use cases like activation, reactivation, or product updates.

Bonus ideas

Most teams still treat lifecycle emails like static templates. But flows like this, powered by real data and LLM logic open a whole new chapter in how we talk to users.

Here’s what this setup can also do 👇

1. Smarter onboarding

Instead of sending a fixed welcome sequence, imagine onboarding that adapts to what each user has (or hasn’t) done.

• Did they skip setup? → Send a 1-click tutorial.

• Did they already launch something? → Show advanced use cases.

This kind of adaptive flow shortens time to value dramatically.

2. Activation coaching at scale

Lifecycle flows can become personal coaches.

They could track user actions, identify friction (like “no campaign launched in 3 days”), and send contextual help (video, doc, or community example) automatically.

3. Real-time retention loops

Your product already knows when engagement is dropping.

Why not trigger a personalized “what changed?” email that re-engages users before they churn?

Not with discounts, but with tailored insights: “You sent 40% fewer messages this week, here’s why it matters.”

4. Expansion & upsell without pressure

Instead of static pricing reminders, lifecycle emails can surface usage milestones:

“You’ve hit 97% of your plan capacity for 3 month in a raw, here’s how teams like yours upgraded.”

Upsell feels natural when it’s data-backed and contextual.

👉 The ultimate goal for any SaaS company, is to have a proactive lifecycle, not reactive.

This kind of setup isn’t common yet. Most teams are still sending static “tips & tricks” flows.

But as AI keeps progressing, and as data pipelines become easier to automate, this will become the new standard for how SaaS products engage, activate, and retain users.

With 100,000 users across 2,500+ companies, it’s a tool every modern go-to-market team wants in their stack.

Here’s the catch: Clay is powerful - so powerful it can feel overwhelming.

It can do lead enrichment, outbound personalization, prospect research, market mapping… the list goes on.

That flexibility is what makes it great, but also what makes it hard to start.

For new users, the question isn’t “Is this useful?” but rather “Where do I even begin?”

Even their tech-savvy ICPs were dropping off before they ever experienced Clay’s real power.

That’s the exact problem Kash, Clay’s Lifecycle Marketing Lead, set out to solve.

She rebuilt the onboarding to deliver fast, relevant wins.

Here’s the teardown of how Clay transforms free sign-ups into engaged, active users.

But for who Clay is built for?

Clay’s audience is highly technical and execution-driven. They typically fall into 2–3 main profiles:

1. Growth & RevOps teams in B2B SaaS

   • Used to stitching tools together and running complex workflows.

   • Value content that gives them an edge without wasting time.

2. Outbound sales teams

   • Live inside CRMs and enrichment tools all day.

   • Expect fast results, minimal setup, and examples they can plug in immediately.

3. Freelance growth operators & consultants

   • Work across multiple clients and industries.

   • Gravitate toward repeatable systems they can deploy without starting from scratch.

Across all of them, the behavior is consistent:

• They’re willing to consume onboarding content → if it’s structured, easy to follow, and directly relevant to their role.

• They expect personalized, pre-made examples they can apply instantly.

• If they can’t connect the content to their exact workflow in minutes, they may tune out.

Let’s dive into the email flow 👀

1. They’re personalizing onboarding with Claygent

During my call with Kash, she also shared how Clay uses AI to personalize onboarding content.

New trial signups don’t just get generic “getting started” emails they receive personalized Claybook suggestions based on their ICP.

How it works:

• Clay enriches each signup to identify who they sell to and what their ICP looks like.

• Claygent then recommends a specific Claybook that matches this ICP.

• The email is personalized to show how that user can find more leads like their target customers.

For example:

• An HR tech company (instride.com) received a Claybook focused on sourcing HR leads.

• An Amazon affiliate marketplace got a Claybook tailored to finding e-commerce partners.

All of this is fully automated with AI, turning what would normally be static onboarding into dynamic, ICP-specific guidance.

#1 - The famous welcome email👇

Clay’s first onboarding email is built for ops and growth personas, people who know their way around tools and just need the fastest path to value.

The structure is simple but deliberate:

1. Set the frame: You get the “Onboarding” tag, and a step counter (1/6) so you know this is part of a journey, not a random blast. → Can help to get a better open rate on next emails.

2. Instant credibility: Mentions OpenAI, Anthropic, Canva, Rippling as customers. That’s authority in one sentence, without displaying logos.

3. Three ways to engage.

   • Do something now: “Find your ideal customers” with a clear, single CTA.

   • Learn how it works: Clay 101 intro session.

   • Get inspired: Anthropic case study showing a real workflow in action.
     

This approach makes sense for a technical product. Not every user has the same familiarity with no-code tools, and guessing their level is risky. Instead, Clay gives each type of user an open door.

The layering is smart: the first CTA targets action-oriented users ready to jump in, while the next two cater to those who want context before committing. No matter your learning style, there’s a clear next step.

And whichever of the three doors you open first gets you closer to your “aha” moment.

Where I’d experiment:

• Role-based variants: For ops, lead with automation/CRM sync; for growth, lead with enrichment and sourcing speed.

• CTA wording: “Start building” vs. “Find your first 50 ideal customers.” The latter makes the outcome feel immediate. But that’s details.

Email #2 👇

Structure analysis:

Header:

• Same visual identity as Email #1 (logo, “ONBOARDING” label, step indicator now at 2/6).

• Title “Dive deeper” → signals progression and moving beyond the basics.

Main content blocks:

1. Resources and use cases

   • Sets the frame: “No one right way to become an expert” → positions Clay as flexible and that’s normal if you’re struggling a bit to use it.

   • Encourages 3 paths: join a cohort, try a workflow, learn from other teams.

2. Clay cohorts (main CTA)

   • Hands-on, community-led learning format.

   • Incentive: up to $5K in additional credits for participation.

     • They know it’s the key for users to test and activate without worrying about credit budgets on top of their Clay subscription.

3. Continue exploring

   • Enrich inbound leads: quick how-to for a common use case.

   • Vanta case study: social proof with a real-world growth experiment.

The good points:

• Clear progression from Email #1: The first email gave “three doors,” this one leans into deeper learning and exploration.

• Multiple learning paths: Cohorts for structured learners, use case how-to for action-takers, case study for inspiration.

• Incentive to engage: Cohort credits give a tangible reason to participate.

• Social proof alignment: Vanta is relevant to ops/growth personas; highlights CRM integration and workflow automation.

• Consistency in layout: Makes it easy to recognize as part of the same series, reducing cognitive load.

Suggestions to A/B Test

A/B Test 1 — Primary CTA placement

• Variant A: Current → cohort block is the first CTA.

• Variant B: Put the “Enrich inbound leads” use case first for users who prefer immediate application over structured programs.

  Purpose: See if direct application beats structured learning as a motivator in week 1.

A/B Test 2 — Incentive framing

• Current: “Earn up to $5K in additional credits” → Users may not understand how credits apply to their workflows or what $5K represents in terms of actual usage.

• Variant: “Get $5K in Clay credits to build your first projects” → Tie credits directly to a concrete outcome.

  Purpose: Make the incentive feel more connected to their immediate goals.

A/B Test 3 — Case study angle

• Current: “How Vanta uses Clay for growth experiments.”

• Variant: “How Vanta cut lead routing time by X% with Clay.”

  Purpose: Test if quantifying results drives more clicks from results-focused personas.

Email #3 👇

Structure of the emails remains the same as previous ones, so we’ll not focus on it.

Content Analysis

Enrichment is one of Clay’s core features, and likely a key activation step for new users.

That’s why the intro copy focuses on how to approach it correctly: if you feed Clay with messy or incomplete inputs, you’ll only get messy outputs back.

The reminder is subtle but important, even with a powerful enrichment engine, data quality starts with the user.

• Strengths:

  • Good baseline for non-technical users who might not know where to start.

  • Positions Clay as both flexible (bring your own data) and complete (native datasets).

• Weaknesses:

  • Reads like documentation, not onboarding.

  • Doesn’t highlight why enrichment matters (faster prospecting, cleaner CRM, higher outreach conversion).

• Improvement: Add outcome-driven framing, e.g., “Enrichment is how you turn a messy list into a high-quality pipeline.”

The Jigsaw Framework (video)

• What it says: Learn to identify base info, then use Clay’s waterfall enrichment to layer 100+ providers.

• Strengths:

  • “Framework” language gives structure (appeals to ops personas who like mental models).

  • Video format fits users who prefer visual walkthroughs.

• Weaknesses:

  • No preview of what you’ll get by the end of the lesson.

  • “Jigsaw Framework” is a nice brand, but not self-explanatory. A new user doesn’t know if it’s worth 5–10 minutes.

• Improvement: Add an outcome line under the video, e.g., “In 5 minutes, you’ll enrich your first list with job titles, company size, and LinkedIn URLs.”

CRM enrichment block

It’s a critical feature for ops, directly addressing the personas who spend their days inside CRMs. In my view, it deserved stronger emphasis in the flow.

• Strengths of the section:

  • Connects Clay to existing workflows → lowers adoption barrier.

  • Speaks directly to ops personas who live inside CRMs.

• Only improvement point for this block is that the visual is generic (just a form).

Share

My fav email of the flow (a spin-off email)

This is my favorite email from Clay’s onboarding sequence.

Why? Because it uses real data from my own usage + break the flow.

Instead of a static, one-size-fits-all template, the content adapts to my ICP and goal, making it feel directly relevant.

When I spoke with Kash, the person who designed the flow, she told me this personalization is deliberate: the content changes based on your ICP and what you’re trying to achieve, so every user gets guidance that feels like it was written just for them.

The email itself looks simple:

• A short congrats on my first week.

• A reminder that I’m on a 14-day free trial with 1,000 credits available.

• A clear breakdown of how credits actually work + subtil reminder of Clay possibilities.

It’s straightforward, but effective: it ties back to my real activity, it explains the system clearly, and it pushes me to keep testing the product.

Emails 4–6: Learning Axes

The last part of Clay’s onboarding sequence (AI, Signals, Claybooks) follows the same philosophy as the first three: each email picks one axis of the product, frames it around a clear use case, and then layers resources and examples so users can go deeper if they want.

They’re essentially “learning emails”. Not hard sells, not overwhelming tutorials, but curated doors into the product:

• Quick framing at the top → why this axis matters.

• Practical example or framework → how to apply it.

• Social proof or playbooks → inspiration from others already doing it.

The strength here is consistency.

Every email feels like a self-contained lesson that teaches you one piece of Clay, while leaving space to explore the next.

For technical, growth-driven personas, this pacing makes sense: it avoids the trap of dumping the whole toolbox at once, and instead guides users step by step toward their own “aha” moments.

What could improve:

• Some intros are too descriptive → they explain the feature instead of selling the outcome.

• CTAs could be sharper and more outcome-driven (“Learn to enrich your first 50 leads” vs “Go to the lesson”).

• A layer of personalization (based on what the user has or hasn’t done yet) would make these learning axes feel less generic and more like tailored nudges.

The 2 last emails

What works:

• Clarity: Both emails are straight to the point: trial ending, here’s what happens, here’s how to upgrade.

• Highlights: Listing Pro plan features keeps the value fresh in the user’s mind.

• No hidden tricks: They reassure users there’s no auto-charge (reduces friction and distrust).

What could be better

• Timing & emotional hook

• The first email says “Your trial expires soon” but doesn’t highlight what you’ll lose when it expires.

• Instead of neutral copy, use urgency tied to outcome:

“Don’t lose access to 25K row searches, your trial ends tomorrow.”

• Personalization

  • These emails feel like boilerplate. They could adapt based on usage:

    • If I enriched leads → remind me I’ll lose enrichment credits.

    • If I connected CRM → remind me I’ll lose CRM sync.

  • This ties back to Clay’s strength: relevance by ICP + activity.

• The free account positioning

  • The “moved you to Free with 100 credits” (second email) is smart, but it’s underplayed.

  • Could frame it as generosity:

    • “We’ve added 100 bonus credits so you can keep exploring, even after your trial.”

      Shifts tone from loss → gift.

• CTA framing

  • “Upgrade now” is fine, but generic.

How they increase the perf. of the flow

Kash also shared a few tactics they use to keep performance high and make the onboarding feel alive, not static.

• Signals-triggered emails: When a user configures a signal that fires in their account, Clay sends a dedicated email.

  • The goal is to reinforce the behavior and help build the habit of coming back. These go out not only to new users but also to existing customers.

• Role-based variants: The onboarding emails aren’t identical for everyone.

  • Ops, growth/marketing, and “default” users each get slightly different messaging. For example, marketers see case studies and examples that highlight campaign use cases, while ops personas get nudges tied to CRM and workflow automation.

• Re-activation emails: Just launched recently, these go to trial users who haven’t been active in their first 30/60/90 days.
  
  Instead of a generic “come back” nudge, they showcase aggregated product stats on how top GTM teams are succeeding with Clay. It’s designed to spark curiosity and get inactive users to give the product another shot.
  They’re currently testing this as a growth experiment to measure re-engagement impact.

  

My conclusion

Clay’s onboarding flow is designed for a specific type of persona: people who are technical, curious, and willing to learn.

Instead of hiding complexity, it embraces it, the flow is structured almost like a mini learning program.

You can come back to it anytime and use it as a reference, which is exactly what works when your users enjoy exploring new tools.

The big strength is consistency: each email teaches one core use case at a time (enrichment, AI, signals, Claybooks), then opens a few “doors” around it: a quick win, a framework, and a case study.

That balance keeps the product powerful without overwhelming you.

Still, there’s room to push it further:

• Behavior-based triggers: If someone hasn’t enriched yet, send a direct “launch your first enrichment” nudge. If they already enriched, skip ahead and show advanced workflows.

• Adaptive conversion nudges: When a user hits their first aha moment (like a live workflow running or a signal firing), that’s the right time to push an upgrade CTA.

• Account-level plays: If the person signing up isn’t an ops persona but the company has a large headcount, trigger an outreach email to the ops team. Example: “Your sales team is already using Clay, connect your CRM to get the most out of it.” This creates internal stickiness and spreads adoption.

• Role-based support: A sales rep might get nudged to invite ops. An ops manager might get invited to join a cohort. A RevOps leader might get sent a case study. Each path builds relevance.

👉 The lesson: when your product is flexible and complex, onboarding shouldn’t just be a feature tour.

It should act like a guided curriculum, adapting that curriculum in real time to what the user does (or doesn’t) do.

Leave a comment

Like it or not, these emails are essential. They help users get value faster.

But recently, I signed up to Resend.

(I’m working on lemlist’s new onboarding email flow, so I wanted to see what others do.)

And Resend surprised me:

👉 Their entire onboarding is just one email.

Let’s break down how and why it works.

1. What is Resend (aka why they do that)

Resend is a modern email editor for developers.

Not marketers. Not founders.

Only developers.

👉 That changes everything.

Unlike typical email editors designed for marketers or founders, Resend’s ICP is developers only.

So Resend rewrote the playbook and tailored everything to devs.

Devs read docs. They love precision. They dive deep.

So they skipped the usual “best practices” marketers blindly follow.

I’m no expert on devs, but one thing is clear:

• Devs read documentation way more than marketers or founders.

• They prefer solid docs over dozens of onboarding emails.

That’s why Resend sends only one onboarding email.

They trust their free trial users will read it. And they won’t spam their inbox for 10 days.

Subscribe now

2. The email

Here’s what Resend’s one email looks like:

• A quick, human intro from the founder, Zeno

• Why Resend exists: a simple, fast, elegant email API that just works, for developers

• Three clear steps:

  1. Send your first email

  2. Add your domain

  3. Check the docs

This structure is very similar to what we use at lemlist for technical onboarding emails.

They provide the bare minimum info needed to get started and activate users quickly.

But Resend goes a bit further.

Because they know there won’t be any follow-up onboarding emails (except product updates when new features launch).

So they keep it short and useful. No fluff.

The email structure and copy confirms. It’s a tool made for devs, by devs:

• You can read it all in one go.

• Each section is short and sharp.

Section 1: Humanisation + The why of Resend

The founder introduces himself and explains why they built Resend.

You’ll notice the phrase “just works”.

These simple 2 words speak volumes to developers.

This means no bugs. No complicated setup. No extra noise.

They can do it because their product goal is simple: send emails reliably.

So in this context, the 2 words “just works” builds trust instantly.

Section 2: Three simple steps to get started

Only three steps. No overwhelming checklist.

The last step is “check the docs.”

Even if you’re not a developer, the docs are well-made and easy to follow:

• You can quickly identify your current tech stack, then follow a recipe-like guide inside the app to configure Resend.

Devs love this. They want solid documentation, not hand-holding emails.

Section 3: Engagement through conversation

At the end, they boldly ask:

“Why did you sign up? What brought you here?”

This is a clever move I’ve seen in other onboarding emails targeting technical audiences.

It encourages replies and creates a feeling of community.

For developers, knowledge sharing and direct communication matter a lot.

This transforms a simple onboarding email into a relationship builder.

Share

The key takeaway for you

I’m not saying you should cut all emails from your onboarding.

But you need to rethink your ICP. (especially if you’re targeting several ICPs).

How do they work? How do they read? How much time are they willing to spend?

Most SaaS send dozens of onboarding emails with low open rates.

Resend shows you can do less and still win.

So look at your flow:

• Are you matching your ICP’s habits?

• Are your emails actually read?

• Or are you just sending noise?

Ship smarter.

It’s about creating a structured, personalized experience that helps your users reach their "aha!" moment faster—and convert. 💰

This guide gives you a full checklist and practical advice to build an onboarding sequence your users will love (and that drives MRR).

👉 How to use this framework

Take a few minutes to answer each question in the sections below.

Once you’ve gone through them, you’ll have a clear picture of your user’s journey, goals, and context.

With that in mind, you’ll be able to map out an onboarding email flow that’s relevant, focused, and complete—without missing any key step.

Use it as your prep doc before writing a single email. It will save you hours later.

1. Start with your business context

1. What type of SaaS are you?
   Self-serve? Sales-assisted? Enterprise? This affects tone, depth of guidance, and pacing. PLG tools need fast onboarding. Enterprise might need layered flows.

2. Do you offer a free trial?
   Yes? Then how long is it? A 7-day trial pushes urgency. A 30-day trial allows more nurturing and education.

3. What's your domain and brand tone?
   Emails should come from a recognizable domain and match the tone of your product site. Trust starts at the inbox.

4. Is your pricing public?
   If yes, consider linking it in your later emails to drive upgrades. If no, focus your onboarding on value and qualification.

2. Understand the product experience

1. What does the user journey look like?
   Map the core steps: sign-up → explore → take a key action → invite team → upgrade. Every email should help move the user forward.

   Take example of the Miro flow here.

2. What’s your core value proposition?
   Repeat it often in your onboarding. Remind users what problem you're solving for them.

3. Who are you talking to?
   Job title? Seniority? Use case? Tailor messaging depending on whether you're talking to a CMO, a growth marketer, or a junior dev.

4. What does success look like for the user?
   Do they want to publish a page? Send their first campaign? Invite a team? Your emails should mirror those goals.

5. Is the product intuitive or complex?
   The more complex it is, the more step-by-step guidance you need. Don’t assume they "get it."

6. Which behaviors should trigger emails?
   Use data: If they haven’t invited a teammate after 3 days, remind them. If they used a feature once, suggest the next one.

3. Define your onboarding strategy

1. What’s your onboarding goal?
   Don’t write a single email before answering this. Is it to get them to:

   1. Create a project?

   2. Invite their team?

   3. Hit a usage milestone?

   
   Be specific.

2. What’s your conversion event?
   Define what "success" means. Paid plan? Team activated? Feature adopted? This anchors your flow.

4. Plan your email sequence

1. How many emails will you send?
   Start with 5–7 core emails. Use time-based AND behavior-based logic. Add more based on use case if needed.

2. What’s the right tone of voice?
   Use the tone your users expect. Devs = direct. Marketers = friendly. Enterprise = clear and professional. But always: be human.

3. Will you personalize?
   Use first names, company names, job titles—if it adds relevance. Personalization is not just a greeting.

4. Are you using dynamic data?
   Usage stats, days left in trial, template recommendations… use them to make your emails timely and contextual.

5. What kind of CTAs work best?
   Avoid "learn more." Use actions: "Create your first campaign," "Invite a teammate," "Try this template."

6. Need to support multiple languages?
   If your user base is international, localizing even just your welcome email can increase engagement.

5. Align with brand and inspiration — optional

1. Do you have brand guidelines?
   Keep tone, spacing, visuals, and CTA styling consistent with your site and app.

2. Are you matching visual style?
   Use your brand colors in buttons and headers. Avoid generic templates.

3. Got favorite examples or competitor inspiration?
   Build a swipe file. Learn from brands you admire—and aim to do better.

4. What metrics define success?
   Pick 2–3 core KPIs to track and improve:

   1. Activation rate

   2. Time-to-value

   3. Conversion to paid

Subscribe now

💡 Pro tip: Onboarding doesn’t end at the last email. Keep nurturing users based on behavior: advanced features, team usage, or plan upsell moments.

This cheat sheet helps you ask the right questions before you ever write an email. Nail this part, and the copy will practically write itself.

The Figma template to duplicate is just below 👇

But first, if you enjoyed this edition, a like goes a long way and is always appreciated!

Get the Figma template

We’ll analyze the full sequence, the logic behind it, and—most importantly—how it could be better.

Plus, you’ll get:

• an alternative flow I would have built if I were running onboarding at Miro!

• a secret technique that helps activate large teams 👀

In case you missed it, the part 1: 👇

Miro’s flow — what is the logic behind?

Miro is nailing one thing most SaaS companies struggle with—activation.

Their onboarding email flow is minimal, yet their activation rate is (probably) above target.

That proves how intuitive their product is—users don’t need much guidance.

But that’s not the reality for most SaaS products. Many require hand-holding until users reach the activation step.

3 points where Miro’s onboarding flow gets it right:

→ It stays focused. Every email has a clear goal—no distractions.
→ It’s concise. Users aren’t overwhelmed with unnecessary information.
→ It filters ICPs. Though a bit late in the flow, it segments users effectively.

But here’s the catch—simplicity comes at a cost.

Miro might leave money on the table by not leveraging data, personalization, and post-onboarding engagement.

Subscribe now

How I’d redesign Miro’s onboarding flow

Miro’s current onboarding flow is simple—but it could be much smarter.

Here’s how I’d structure it for higher activation and engagement:

1️⃣ Segment users immediately

I’d filter ICPs as soon as they start using the product, not later.

But job title alone isn’t enough—seniority matters. A marketing manager and an operational specialist might be in the same department but have very different needs.

By identifying who they are and what they need early, emails can deliver the right CTAs and content for their specific job to be done.

2️⃣ Trigger emails based on in-app behavior

Instead of sending generic onboarding emails, I’d track key actions inside the product.

For Miro, inviting team members is a critical adoption factor. If a user hasn’t done it, an email should nudge them at the right time.

Rather than guessing what users need, let their behavior dictate the flow.

3️⃣ Use smart loops on key actions

If a user doesn’t complete an important action, following up is essential—but timing matters. I’d structure reminders so that each repeat CTA gets a +2-day delay (max 3 times).

This prevents spammy repetition while keeping users engaged. The goal is to remind, not annoy.

4️⃣ Activate secondary ICPs - the secret sauce technique

If the primary user (e.g., a CMO) isn’t engaging, that doesn’t mean the account is lost. Instead, I’d engage a secondary ICP—someone else within the company who could drive activation.

For example:

If the CMO hasn’t started a board in Miro, I’d send them a marketing campaign template they could share with their team.

This gives another entry point for engagement—without relying on a single person.

⚠️ Balancing segmentation

Be careful about over-segmentation.

Too many segments can create complexity that’s hard to optimize. However, when backed by data, segmentation becomes a strategic advantage.

Users today expect relevance, not generic emails.

At the same time, companies are collecting less user data than before. That’s why personalization must be meaningful—it needs to build trust first.

Final Takeaways

→ Segment early, but only where it truly matters.

→ Trigger emails based on meaningful in-app behaviors.

→ Don’t just nurture one user—activate the entire company.

→ Be persistent, but not pushy. Timing is everything.

When done right, this approach doesn’t just improve onboarding—it lays the foundation for long-term retention.

As promised, here’s the Figma file with the full flow that you can duplicate.

Get the figma file

Feel free to like—it’s always appreciated! And drop a comment if you have any questions.

Have a great day, everyone!

Miro has scaled to 50M+ users and a $17.5B valuation.

But getting sign-ups is one thing—turning them into active users is another.

I analyzed their entire onboarding email flow to see what they’re doing right, what’s falling short, and what you can learn for your own strategy.

Here’s what you’ll get:

1. The emails sent by Miro & where they could improve it

2. The overall flow → you’ll be able to duplicate it from a FigJam

3. An alternative flow I could have mapped for users who are difficult to activate.

Miro’s business model: How is it shaping their email flow?

Miro runs on a product-led growth (PLG) model, meaning users try the product first and then upgrade as they see its value.

Here’s how their plans work:

• freemium plan → anyone can sign up and use Miro for free (but with a 3-board limit).

• paid plans (team & business) → more boards, integrations, and collaboration tools.

• enterprise → custom pricing, security, and admin features for large teams.

Since there’s no free trial for paid plans, the onboarding emails have one job:

→ make users experience Miro’s value quickly.

Instead of pushing for an immediate upgrade, Miro’s emails focus on:

✅ Getting users to create their first board

✅ Encouraging collaboration by inviting teammates

✅ Showcasing key features to drive engagement

The goal? Hook users early so they naturally outgrow the free plan and upgrade when they need more.

So, how does their email flow actually achieve this?

Email #1 - Verify your email

This is the well-known email verification step—a simple yet essential checkpoint. Many early-stage startups might be tempted to skip it for one main reason:

👉 Reducing friction to boost signups.

But in reality, this small hurdle helps in two big ways:

✅ Filters for more engaged users – Those willing to verify their email are more likely to explore your product.

✅ Prevents typos & lost leads – Ensuring users enter a valid email means you can nurture them effectively during their free trial.

Miro keeps it clean and to the point—no distractions.

But they could take it further by using this moment to build excitement for the product.

For example, instead of a plain confirmation message, they could set the stage with:

• “You’re one step away from turning your ideas into reality.”

Rather than a basic “Verify your email” CTA, a more engaging call-to-action could be:

• “Start creating your flow”

Email #2 - Welcome email — This one is 🔥

⏳ + 5 minutes

The welcome email from Miro is really cool.

✅ It feels like you’re already inside the product.

✅ Personalized design, not just text. They use data from the onboarding flow to visually place you in a teamwork setting, reinforcing their business model.

✅ Key features highlighted. The four most-used features are front and center, making it easy to get started.

What could have been even better?

Miro could have taken personalization one step further by using the job title provided during onboarding in the following section:

For example, they could tailor the email based on use cases instead of a generic introduction.

1. The title of the section:

   1. How marketers craft their first Miro board

2. Feature 2 displayed:

   1. Drag & drop your marketing PPT right onto the canvas

3. Feature 3:

   1. Generate campaign strategies in seconds with AI.

4. Feature 4:

   1. Our most-used marketing templates, ready to duplicate.

Instead of just showing features, this approach ties them to real-world use cases, making the email more relevant and actionable.

Final thoughts on the CTA:

The call-to-action is smart—it encourages users to explore value first rather than rushing them to invite teammates. Miro understands that people are more likely to invite others once they’ve created their first board.

Email #3 - The tutorial email

⏳ + 1 day since last email

The goal of this email is simple: help you get to the “Aha!” moment so that you’ll naturally want to invite your team.

It also clearly maps out Miro users' four key steps, highlighting the most important milestones before most users activate.

Let’s analyze the email:

→ The subject line is spot on—short, easy to read, and clear.

→ The content works well for a general user but seems fluffy.

👉 If they’re collecting data during onboarding (job title, team size, etc.) and don’t use it, they’re missing an opportunity by not taking personalization a step further.

Here is another version:

⚠️ I think it’s missing a clear connection to the job to be done for each user, which can vary based on their role and team size.

For example, in the “how to create content” section, the focus feels incomplete.

It’s not just about creating content—it’s about ensuring that:

→ your team can easily understand it

→ it’s a high-quality asset that adds value

What I would have done here:

Another version of this email could have been more personalized based on my onboarding inputs.

For example, instead of a generic message, they could have included direct links to the dashboards they pre-built for me during onboarding, so I wouldn’t have to start from scratch.

Then, once I began modifying a template or adding elements, they could have triggered an email prompting me to invite my team, reinforcing collaboration at the right moment.

Email #4 - Push template

⏳ + 1 day since last email

This is the fourth email, and the goal is still the same: get me to create a board and invite my team.

But this email should have been sent earlier, replacing email #3.

it does a great job of framing the job to be done with Miro by showcasing their ready-made templates. — I was expecting this a bit earlier.

The content is solid (even if the layout is slightly broken, which happens sometimes), but there’s one problem—it looks too similar to the previous email.

Receiving two emails with almost the same design back-to-back reduces impact.

When everything feels repetitive, the chances of actually engaging drop.

The only issue with this email? the CTA leads to a generic template page instead of something marketing-specific.

It’s not a dealbreaker, but they’re missing a chance to create a small wow effect.

Imagine clicking and landing on a pre-filled marketing board with relevant templates ready to use.

That small touch could make the experience feel more personalized and impactful.

What I would have done here:

1. I would have replaced email #3 by this one

2. The fourth email should have focused on a specific use case related to my job title

3. The goal of an in-app onboarding flow is to collect enough data to make the email onboarding flow relevant and helpful in getting users into the product

   • Here is a proven flow that works for onboarding:

     

4. If they had asked why I was starting a project in Miro, they could have helped me complete that task with a pre-made template—and from there, I could have been activated more easily peasy.

Email #5 - The use case!

I was waiting for this email earlier! But late is better than never 🤔

This works because the template is directly linked to what I might want to create in Miro—I assume it’s one of their top use cases.

The email format is also original because it’s structured as a testimonial from a Miro employee, which does two things:

• 1️⃣ humanizes the brand – many companies miss this, but people trust people more than faceless brands.

• 2️⃣ makes the use case feel real – instead of just promoting a template, they show how a successful company (Miro itself) actually uses it.

The section “Why I like using Miro for customer journey mapping” is a classic testimonial-style approach that promotes the product in a way that feels less pushy. (though, in my opinion, they could have made this section even stronger.)

Both of these elements add credibility to the email and the template, and I wouldn’t be surprised if it performed really well.

The best part? You can easily apply this to your onboarding flow—even if your brand isn’t as well-known.

It’s great for your customers to see that you actually use your own product.

What I would have done here:

Here’s the copy I would have used in that email to make it more customer-focused while keeping its original DNA.

Section 1:

[Video placeholder]

Hey {{first_name}},

I’m Maureen, a product designer at Miro, and I know how tricky mapping a customer journey can be:

• forgetting key touchpoints,

• dealing with scattered insights,

• struggling to connect the dots between steps.

That’s why I’m sharing this structured framework in Miro, which you can duplicate —watch the 3 minute-video above to see how I use it to:

✔️ Map key customer touchpoints in a pre-built timeline

✔️ Organize insights and next steps—without messy spreadsheets

✔️ Collaborate with your team to improve the journey in real-time

This template is a great place to start if you're new to journey mapping.

[try out the template]

Section 2:

Why I love using Miro for customer journey mapping:

→ Everything stays in one place – no more jumping between docs, slides, and spreadsheets to track insights.

→ Collaboration is seamless—teams can brainstorm and refine the journey in real-time. You’ll never lose important feedback.

→ AI speeds things up – Miro AI helps generate user stories, pain points, and key takeaways in seconds.

I’m reaching the email limit, so I need to split Miro’s flow into two parts.

In two weeks, we’ll cover:

• The last emails Miro sent to convert me

• The overall flow → (you’ll be able to duplicate it from a FigJam)

• An alternative flow that I could have mapped for this use case: users that you’re struggling to activate.