Set Up Your Onboarding Email Sequence

Onboarding Emails for Your New SaaS

Goal: Ship a six-email onboarding sequence — three behavioral, three time-based — that takes a new signup from "account created" to "activated, retaining user" without any manual effort. Wire deliverability correctly so it actually lands in the inbox.

Process: Follow this chat pattern with your AI coding tool such as Claude or v0.app. Pay attention to the notes in [brackets] and replace the bracketed text with your own content.

Timeframe: 1 day to first email live in production. Full sequence shipped and instrumented in week 1 of launch.

Why Onboarding Emails Pay Off Twice

Onboarding emails are the single highest-leverage growth lever you have between signup and Day 30, and the math is one-sided. Welcome emails average ~86% open rates — about four times a normal marketing send. Behavioral trigger sequences typically lift activation 2–3× versus a generic time-based drip. And a working email sequence keeps paying out: every signup for the next 12 months walks the exact same path you build this week.

Skip them and you are voluntarily losing 30–50% of your would-be retained users. That is the gap between "left mid-onboarding because nothing nudged them back" and "logged in on Day 14 because an email reminded them why."

For an AI SaaS specifically, the aha moment is almost always the user's first usable AI output. Your sequence's job is to get them there in under seven minutes, then keep them coming back until the value compounds.

This guide assumes you have already done Activation Funnel Diagnosis. If you have not, do that first — without a defined activation event, your emails will fire at the wrong time.

1. Pick a Tool

For a one-person or small team running on Next.js / Vercel, the right pick is almost always Loops or Resend. Both are dev-friendly, behavioral-trigger native, and cheap at startup volumes.

I'm building a SaaS at [your-domain.com]. My stack is [Next.js App Router / React 19 / TypeScript], deployed on Vercel. I use [PostHog / Vercel Analytics / Plausible] for product analytics and [Stripe / Polar / Lemon Squeezy] for billing.

I need to add an onboarding email sequence — six emails over 30 days, three behavioral and three time-based.

Help me decide between:
1. **Loops** — purpose-built for SaaS lifecycle email, behavioral triggers from custom events, AI sequence builder, generous free tier.
2. **Resend** — developer-first transactional + marketing API, React Email templates, low per-email pricing, easy to build custom trigger logic in code.
3. **Customer.io** — full-featured lifecycle marketing platform, advanced segmentation, more expensive but more flexible.
4. **ConvertKit / Kit** — newsletter-first, simpler automations, good if you already write a regular update.

For each option, tell me:
- Setup time on my exact stack
- Cost trajectory at 1k / 10k / 100k MAU
- Behavioral trigger flexibility (can it fire on a custom event like `first_ai_output_generated`?)
- React Email / template DX
- Built-in deliverability monitoring
- API quality for sending transactional emails alongside the lifecycle sequence

Recommend ONE based on my scale, stack, and the fact that I want to send sequences triggered by in-product events. Default to Loops unless there's a strong reason against.

Default pick if you skip the chat: Loops. Behavioral triggers, single dashboard for sequence + transactional, free under 500 contacts, $29/mo at 10k emails.

2. Wire Deliverability Before Sending Anything

A perfect sequence in the spam folder is worth zero. Set this up before you send the first email — it is much harder to repair domain reputation than to start clean.

I have [your-domain.com] hosted on [DNS provider — Cloudflare / Vercel / Route 53]. I'm sending lifecycle email through [Loops / Resend / Customer.io].

Help me configure deliverability properly:

1. **Dedicated sending subdomain** — I want to send from `mail.[your-domain.com]` or `hello.[your-domain.com]` so my apex domain reputation is protected. Tell me which records to add and exactly what values.

2. **SPF record** — TXT record at the sending subdomain authorizing my email provider. Show me the exact value for [chosen tool].

3. **DKIM record** — CNAME or TXT records the provider gives me. Walk through how to find them in [chosen tool] and how to verify they're propagating.

4. **DMARC record** — start at `p=none` for the first 30 days so I can read aggregate reports without bouncing real mail. Show me the exact DMARC value plus a free tool I can use to read the XML reports.

5. **Reverse DNS / PTR** — only relevant if I'm sending from my own server, which I'm not, so I should be fine here. Confirm.

6. **Domain warming** — for a new sending subdomain, what's the right ramp? Start at [50–100] sends per day and grow [50%] daily until I hit my actual volume?

7. **Verification check** — after I've added these records, what's the single command or web tool I can use to confirm SPF, DKIM, DMARC are all green?

Don't skip the DMARC step. I've seen people send for six months before realizing half their mail was being rejected.

The one-line litmus test: paste your sending address into mail-tester.com and aim for 9/10 or higher before sending the first onboarding email. Anything below 8/10 means you have configuration left to fix.

3. Define the Six Emails

Use this skeleton. Adjust copy to your product, but keep the timing, trigger, and single CTA per email.

#	When	Trigger	Email	Goal
1	Day 0, within 5 minutes of signup	`signup_complete` (event)	Welcome + first action	Get them to the activation event in one click
2	Day 1	`activation_event_completed = false` AND 24h since signup (behavioral)	"Stuck? Here's the 2-minute path"	Recover stalled users with a specific nudge
3	Day 3	`activation_event_completed = true` AND 48h since activation (behavioral)	"Here's what to try next"	Push to second-feature use, lock in habit
4	Day 7	Time-based, sent to all still-active users	Social proof + case study	Build trust at the conversion-decision window
5	Day 14	`is_paying = false` AND `activation_event_completed = true` (behavioral)	Conversion offer / extended trial	Convert activated free users
6	Day 30	Time-based, sent to all users not yet churned	"How is it going?" + founder reply	Re-engage and capture qualitative feedback

Three rules that hold across every email:

One CTA per email. Two CTAs cuts click-through by roughly half. Pick the most important action and make everything else point to it.
Acknowledge what they have done. "I noticed you finished setup but haven't generated your first report yet" beats "Hey, generate a report!" every time.
Respect activation state. If a user has already done X, do not send an email asking them to do X. Wire your triggers correctly or you will look broken.

Draft me six onboarding emails for my AI SaaS at [your-domain.com]. The product does [one-sentence description]. The activation event is [the in-product action that predicts retention, e.g., "user generates and saves their first report"].

Use this skeleton:
[paste the table above]

For each email, give me:
1. Subject line (under 50 characters, no clickbait)
2. Preheader text (under 90 characters, complements the subject — does not repeat it)
3. Body in plain text — short paragraphs, one CTA, written like a personal note from the founder
4. Single CTA button copy (action verb + object, e.g., "Generate my first report")
5. Optional P.S. line that adds value (a tip, a link to docs, a Slack invite)

Tone: clear, warm, slightly informal. Sound like a founder who genuinely wants this user to succeed, not a marketing automation. No emojis except where they earn their place.

Format the output as Markdown so I can paste it into [chosen tool] without reformatting.

4. Wire the Behavioral Triggers

Time-based emails are easy — every tool supports them. Behavioral emails are where most teams fail, because they require sending events from your app to your email tool.

The pattern: every meaningful in-product action emits an event. The email tool subscribes to those events and fires (or holds, or skips) emails based on them.

I'm using [Loops / Resend / Customer.io] for email and [PostHog / Segment / direct API calls] for events.

Help me wire behavioral triggers for my onboarding sequence:

1. **Identify the events I need to send from my app**:
   - `signup_complete` (fires after account creation finishes)
   - `activation_event_completed` (fires the first time the user hits my activation event — for me this is [your activation event])
   - `subscription_started` (fires when the user upgrades to a paid plan)
   - Any other event my sequence branches on

2. **For each event, show me**:
   - Where in my Next.js codebase to fire it (Server Action? API route? Webhook handler from Stripe?)
   - The exact API call to [chosen tool], with the user identifier, timestamp, and any relevant properties (plan tier, source, etc.)
   - Idempotency — how to make sure I don't double-fire if the user signs up twice in the same session

3. **Configure the triggers in [chosen tool]**:
   - Email 2 fires when 24h has passed since `signup_complete` AND `activation_event_completed` is null
   - Email 3 fires 48h after `activation_event_completed` fires
   - Email 5 fires when 14 days have passed since `signup_complete` AND `activation_event_completed` is true AND `subscription_started` is null
   - Other emails are time-based and need no trigger

4. **Build a test harness**: a debug page or a CLI script that lets me simulate each event for a test user and watch the sequence advance. Without this, every iteration is a live test on real users.

Show me the exact code, not pseudocode. I want to paste this into my repo and have it work.

The test harness step is non-negotiable. The first time you ship a behavioral sequence, your triggers will be wrong, and the only way to find that out before customers do is to simulate the events end-to-end yourself.

5. Use Your Activation Event as the Branching Point

Most onboarding sequences are linear: Day 1, Day 3, Day 7, send everyone the same thing. Linear sequences work for newsletters. They are wrong for onboarding, because activated users and stalled users need opposite messages.

After signup, every user lives in one of two states:

Stalled — has not hit the activation event. They need a re-engagement nudge with a smaller ask. ("Did you get stuck? Here is a 2-minute path to your first output.")
Activated — has hit the activation event. They are warm. Push them to deeper feature use, social proof, conversion. ("You generated your first report yesterday. Here is the one feature most users love next.")

If you send the same Day 3 email to both, you will tell stalled users about advanced features they can't use yet (and feel dumb about), and you will tell activated users to "try your first action!" (which they already did three days ago — and now you look broken).

Audit my current sequence design and tell me where I'm sending the wrong email to the wrong user state.

For each email in my sequence, output:
1. The state(s) it should fire for — stalled, activated, paying, or all
2. The current trigger I have configured
3. Whether the trigger correctly excludes users it shouldn't reach
4. The fix if it doesn't

Then build me a state diagram showing the user lifecycle:
- New signup → (24h activation window) → Stalled OR Activated
- Activated → (14d conversion window) → Free Activated OR Paying
- Paying → (continued use)
- Any state → (30d inactivity) → Dormant → win-back path

Each email should be tied to exactly one transition, not just "Day N."

6. Set Hard Exit Conditions

Email sequences that don't know when to stop are worse than no sequence. The two exits every onboarding flow needs:

Exit on success. When the user converts to paid, exit them from the trial sequence. Do not send them "convert now!" emails after they already converted.
Exit on disengagement. If a user has not opened an email in 14 days, pause the sequence and add them to a low-frequency reactivation list. Continuing to send to people who never open damages your domain reputation, drags down your sender score, and pushes the rest of your mail toward spam.

Add exit conditions to my onboarding sequence:

1. **Conversion exit**: when `subscription_started` fires for a user, immediately remove them from the trial sequence and move them to the [paid-user lifecycle / customer success] track. Email 5 (the conversion offer) must also be skipped if they upgraded before Day 14.

2. **Engagement exit**: if a user has not opened any email in the sequence within 14 days, pause future sequence sends. Move them to a "dormant" segment. After 30 days dormant, optionally trigger one win-back email — if they don't open that, hard-suppress.

3. **Hard suppression**: any user who unsubscribes, hard-bounces, or marks an email as spam is removed from ALL sends, transactional excepted. Show me how this is enforced in [chosen tool] and confirm it's automatic — I never want to manually maintain a suppression list.

4. **Re-entry rules**: if a dormant user logs back in and triggers `activation_event_completed`, they re-enter the sequence at Email 3 (post-activation), not Email 1. Confirm this is configurable.

Don't skip exit logic. The reason most B2B SaaS hits 30%+ spam complaint rates is that they keep emailing people who stopped engaging six months ago.

7. Measure What Matters (Not Open Rates)

Open rates are no longer reliable as a primary metric. Apple Mail's privacy protection pre-fetches every email image, which inflates opens by 40–80% depending on your audience. Track the metrics that survive privacy changes.

For each email in the sequence, instrument:

Metric	How to measure	Healthy range (early-stage AI SaaS)
Click rate (CTR)	Clicks on the primary CTA / total sent	8–25%
Click-to-conversion	Users who clicked AND completed the email's intended action	30–60% of clicks
Sequence-attributed activation	New users who activated AND clicked at least one onboarding email	40–60%
Sequence-attributed conversion	Free → paid conversions where the user clicked the conversion email within 7 days	5–15% of activated users
Unsubscribe rate	Unsubs / sent, per email	<0.5% per email; >2% = your copy is wrong
Spam complaint rate	Reported as spam / sent	<0.1%; >0.3% Gmail will throttle you

Help me build an onboarding email dashboard.

Source data: [Loops / Resend / Customer.io] event exports + [PostHog / my product database] activation and conversion events. Join key is the user email or user ID.

Output: a single page in [my BI tool / a Next.js admin route] showing for the last 30 days:

1. **Sequence funnel** — for each email (1 through 6): sent → clicked → primary CTA action completed. Side-by-side as a horizontal funnel.
2. **Cohort retention curve** — Day 1 / 7 / 30 retention split by "engaged with sequence" (clicked any email) vs. "did not engage." This is the chart that proves the sequence is or isn't working.
3. **Attribution leaderboard** — which email generated the most activations, the most conversions, the most unsubscribes. Sort by clicks descending.
4. **Deliverability scorecard** — bounce rate, complaint rate, unsubscribe rate, per email and aggregate. Red-flag any email exceeding the healthy range.
5. **Trigger health** — for each behavioral trigger, last fire timestamp, fire count last 24h. Catch broken triggers within a day, not a quarter.

Refresh nightly. Don't rely on the [chosen tool] built-in analytics — it stops at "opens and clicks" and misses the conversion attribution that matters.

Common Failure Modes

"Everyone gets the same email regardless of state." Linear sequence, no behavioral branching. Fix: wire activation event triggers per Section 5. The single biggest difference between sequences that work and sequences that annoy users.

"Open rate is 12%." Either your subject lines are bad or your deliverability is broken. Run mail-tester.com first — if you score below 8/10, the inbox isn't the problem, the mail isn't getting there. If 9/10+ but still 12%, rewrite subject lines (shorter, specific, no clickbait).

"We sent the conversion email to someone who upgraded yesterday." Missing exit condition. Every sequence must check is_paying before sending conversion-targeted emails. This bug costs you trust faster than any other.

"Users complain about getting too many emails." You are sending more than six in 30 days, or you are sending without behavioral suppression so opens with the same content twice. Cut frequency before adding more emails. Six over thirty days, well-targeted, beats fifteen with no targeting.

"The behavioral trigger never fires." Almost always because the in-product event is not being sent. Check your event log in [chosen tool] — if activation_event_completed is missing, the email tool can't fire on it. Build the test harness from Section 4 and verify every event end-to-end.

"Spam complaints are climbing." You are emailing dormant users. Implement engagement exit (Section 6) and hard-suppress users with no opens in 30+ days. Domain reputation takes weeks to recover after a bad complaint week.

"We never updated the copy." First-version copy that sat in production for a year. Onboarding copy decays — your product changes, your ICP sharpens, your benchmarks shift. Re-read every email every quarter and rewrite the worst-performing one.