Email Sequences for SaaS Onboarding: What to Send and How to Build It

When a user signs up for your SaaS, you have about 10 minutes of genuine attention before they move on. A well-designed onboarding email sequence is how you earn back that attention later — guiding them toward the activation moment that separates retained users from churned ones.

1. Why sequences outperform one-off emails

A single welcome email is better than nothing, but it has a fundamental problem: it arrives when users don't yet know what they don't know. They just signed up — they haven't hit any obstacles yet, haven't reached any milestones, and can't fully appreciate which features matter.

Email sequences solve this by distributing guidance over time, aligned with where users actually are in the product. Email 1 arrives when they're excited. Email 3 arrives when they might be getting stuck. Email 5 arrives when they're deciding whether to upgrade.

The data backs this up: for most B2B SaaS products, a 5–7 email onboarding sequence that stops when users complete key actions has 2–3x better activation rates than a single welcome email.

2. The 5-email onboarding framework

Here's the sequence structure that works for most SaaS products. Adjust the specific content to match your activation events.

3. Timing: when to send each email

Timing is where most onboarding sequences get it wrong. Two rules:

1. Stop the sequence when users activate. If someone has already completed the step you're nudging them toward, sending that email is counterproductive — it signals you're not paying attention. This requires behavioral triggers, not just time-based sends.

2. Respect business hours. If your product is B2B, send at times when professionals check email: Tuesday–Thursday, 8am–11am in the recipient's timezone. Most email APIs can handle timezone-aware sending if you store the user's timezone on signup.

4. Implementation: building the sequence in code

There are two ways to build this: with a purpose-built sequence tool, or by wiring it yourself in application code. Here's the tradeoff:

Option A: Use a sequence API (recommended)

Services like tinysend let you define the sequence once and enroll users with a single API call. The service handles timing, unsubscribes, and stopping conditions.

async function enrollInOnboarding(user) {
  await fetch('https://api.tinysend.co/v1/sequences/onboarding-v2/enroll', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.TINYSEND_API_KEY}`,
      'Content-Type': 'application/json',
      'X-Idempotency-Key': `enroll-onboarding-${user.id}`,
    },
    body: JSON.stringify({
      email: user.email,
      variables: {
        first_name: user.firstName,
        product_url: `https://app.example.com/dashboard`,
        activation_url: `https://app.example.com/getting-started`,
      }
    })
  })
}

// Call immediately after email verification
await enrollInOnboarding(newUser)

Option B: Build it yourself with a job queue

If you're using a job queue (Bull, Sidekiq, Celery), you can schedule each email as a delayed job. More control, more maintenance.

import Queue from 'bull'
const emailQueue = new Queue('emails')

async function scheduleOnboardingSequence(user) {
  const delays = [
    { template: 'welcome',         delay: 0 },
    { template: 'nudge',           delay: 24 * 60 * 60 * 1000 },      // 1 day
    { template: 'case-study',      delay: 4 * 24 * 60 * 60 * 1000 },  // 4 days
    { template: 'feature-spotlight', delay: 7 * 24 * 60 * 60 * 1000 }, // 7 days
    { template: 'upgrade-offer',   delay: 12 * 24 * 60 * 60 * 1000 }, // 12 days
  ]

  for (const { template, delay } of delays) {
    await emailQueue.add(
      { userId: user.id, template },
      { delay, jobId: `onboarding-${user.id}-${template}` } // idempotent job ID
    )
  }
}

// Job processor
emailQueue.process(async (job) => {
  const { userId, template } = job.data
  const user = await User.findById(userId)

  // Skip if user already activated (for nudge email)
  if (template === 'nudge' && user.activatedAt) return

  // Skip if user cancelled or unsubscribed
  if (user.cancelledAt || user.unsubscribedAt) return

  await sendEmail({ to: user.email, template, variables: { user } })
})

5. Triggering sequences from your app

The right place to enroll users in an onboarding sequence is immediately after email verification — not at initial signup. Reason: if a user never verifies their email, you're sending onboarding emails to a dead address.

app.get('/verify-email', async (req, res) => {
  const { token } = req.query
  const user = await verifyEmailToken(token)

  if (!user) return res.status(400).send('Invalid token')

  // Mark verified
  await user.update({ emailVerifiedAt: new Date() })

  // Enroll in onboarding sequence
  await enrollInOnboarding(user)

  // Redirect to app
  res.redirect('/dashboard?onboarded=true')
})

Stopping the sequence when users activate

Define your activation event clearly — it should be the single action that predicts retention most strongly. For a project management tool, it might be "created first project AND invited a teammate." Fire a stop event when this happens:

async function onUserActivated(userId) {
  const user = await User.findById(userId)
  await user.update({ activatedAt: new Date() })

  // If using tinysend sequences — unenroll from onboarding
  await fetch(`https://api.tinysend.co/v1/sequences/onboarding-v2/unenroll`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${process.env.TINYSEND_API_KEY}` },
    body: JSON.stringify({ email: user.email })
  })

  // Now enroll in the post-activation "power user" sequence
  await enrollInPowerUserSequence(user)
}

6. Common mistakes and how to avoid them

7. What to measure

Email opens are a vanity metric — open tracking is unreliable since iOS 15. Focus on:

The most important experiment: A/B test the stop condition. Compare "stop when user activates" vs "send all emails regardless" on activation rates 30 days after signup. This tells you whether your later emails are helpful or counterproductive.