---
title: "Welcome Email Sequences That Actually Convert"
description: "A practical SaaS welcome email sequence: the five emails worth sending, when to send each one, subject lines, how to stop nudging users who already activated, and how to build it as an automation in Reloop."
canonical: "https://reloop.sh/blog/welcome-email-sequences-that-convert"
last-updated: "2025-11-04"
---

# Welcome Email Sequences That Actually Convert

> For the site documentation index, see [llms.txt](/llms.txt). Docs index: [llms-docs.txt](/llms-docs.txt). Marketing corpus: [llms-full.txt](/llms-full.txt). Docs corpus: [llms-full-docs.txt](/llms-full-docs.txt). Product skill: [skill.md](/skill.md). Prefer markdown URLs (append `.md`) when available.

> A practical SaaS welcome email sequence: the five emails worth sending, when to send each one, subject lines, how to stop nudging users who already activated, and how to build it as an automation in Reloop.
Source: https://reloop.sh/blog/welcome-email-sequences-that-convert
Published: 2025-11-04
**A welcome sequence converts when every email pushes the user toward one action: the first moment your product is actually useful to them.** Send the first email immediately, follow up only while they haven't reached that moment, and stop the moment they do. Five short emails over about two weeks, each with a single call to action, beats a long newsletter-style drip every time.

This guide covers what "convert" should mean for your product, the five emails worth sending, how to time them, and how to build the whole thing as an automation in Reloop that skips users who've already activated.

---

## First, decide what "convert" means

"Convert" is not "opened the email" or "clicked a link." It's the first action that predicts a user will stick around. Product teams call it the **activation event**.

| Product | Activation event |
|---|---|
| Email API | First email sent from their own verified domain |
| Analytics tool | First dashboard with real data |
| Project management | First project with a teammate invited |
| Design tool | First file shared or exported |
| Payments | First live charge |

Pick one. Write it down. Every email in the sequence exists to move the user one step closer to it, and the sequence should know when they've done it so it can stop.

If you don't know your activation event, look at the users who are still active after 90 days and find the action almost all of them took in their first week. That's your starting guess.

---

## The five-email welcome sequence

Here's a sequence that works for most self-serve SaaS products. Adjust the days to match how long your activation usually takes.

| # | When | Goal | Example subject |
|---|---|---|---|
| 1 | Immediately | Confirm signup, point to the first step | Welcome to Acme: here's where to start |
| 2 | Day 1 | Remove the most common blocker | The one setting most people miss |
| 3 | Day 3 | Show the outcome, not the feature | How Lin's team cut reporting from 3 hours to 10 minutes |
| 4 | Day 7 | Offer help from a person | Stuck? Reply to this email |
| 5 | Day 14 | Last nudge, with a reason to come back now | Your workspace is ready when you are |

Emails 2 to 5 only go to users who **haven't** activated yet. A user who activates on day 1 should get email 1 and nothing else from this sequence. Activated users move to a different track (tips for power users, [team invites, upgrade prompts](/blog/transactional-email-as-growth-channel)) or get no more automated email at all.

### Email 1: the welcome (immediately)

This is the email people are most likely to open, because they just signed up and they're waiting for it. Don't waste it on a company history.

- Confirm what they signed up for in one line.
- Give **one** next step, as a button.
- Tell them who to contact if they're stuck.

```text
Subject: Welcome to Acme: here's where to start

Hi,

Your Acme account is ready.

The fastest way to see what Acme does is to connect your first
data source. It takes about two minutes.

[Connect a data source]

If anything's unclear, reply to this email. It goes to a real person.

Pranav, Acme
```

### Email 2: remove the blocker (day 1)

Look at where new users drop off. Usually it's one setup step: [verifying a domain](/blog/spf-dkim-dmarc-setup-guide), installing a snippet, inviting a teammate. Email 2 explains that step and why it matters.

Keep it short. Link straight to the screen where they do it, not to your homepage.

### Email 3: show the outcome (day 3)

By day 3, users who haven't activated often don't see why they should bother. Show a concrete result someone like them got. A short story about a real customer, with permission, works better than a feature list.

### Email 4: offer a human (day 7)

A plain-text email from a founder or support engineer asking "what's getting in the way?" gets replies, and the replies tell you exactly what to fix in onboarding. Make sure replies go to a real inbox someone reads.

### Email 5: the last nudge (day 14)

Give them a reason to come back now: a template they can start from, a short video, a new feature. Then stop. Users who haven't activated after two weeks need a product change, not a sixth email. Users who activate and later drift away are a job for [churn sequences](/blog/email-reduce-churn-sequences).

<Callout type="tip">
  Send the welcome sequence from a person's name ("Pranav from Acme"), not "Acme Team" or `noreply@`. Use a `reply_to` address someone actually reads.
</Callout>

---

## Rules that make a sequence convert

**One call to action per email.** Two buttons halve the clicks on both.

**Stop when they activate.** Nothing erodes trust faster than "Have you tried connecting a data source?" the day after they did.

**Short beats clever.** Most welcome emails are read on a phone in a few seconds. Aim for under 150 words.

**Plain text is fine.** For emails 1, 4 and 5, a lightly formatted email that looks like it came from a person often does better than a designed newsletter.

**Separate it from transactional mail.** [Password resets](/blog/password-reset-email-best-practices) and receipts should never wait behind a marketing queue or share a reputation with it. Send onboarding from its own subdomain if you can.

**Respect unsubscribes.** Every sequence email needs a working unsubscribe link, and unsubscribing should stop the sequence immediately.

---

## Build it in Reloop

Reloop runs welcome sequences as **automations**. Your app tracks an event when someone signs up, the automation sends emails, waits, and checks conditions. Because conditions read the contact's data at the moment the step runs, the sequence can check whether the user has activated before each nudge.

Here's the setup end to end.

### 1. Create the templates

Create one [template](/docs/learn/templates) per email in the dashboard. Each template carries its own subject and From address.

Templates support variables written as `{{{name}}}` with a default value. Automation steps send the template with those defaults, so write sequence emails that read naturally without per-user data. If an email needs user-specific numbers, send it from your app with `reloop.mail.send` and pass `template.variables` instead.

### 2. Add an `activated` property

Create a [contact property](/docs/learn/contacts/properties) called `activated_at` (String). When a user hits your activation event, set it from your app:

```typescript

const reloop = new Reloop({ apiKey: process.env.RELOOP_API_KEY! });

  const { contactError } = await reloop.contacts.update(contactId, {
    properties: { activated_at: new Date().toISOString() },
  });
  if (contactError) console.error(contactError);
}
```

### 3. Create the trigger

A trigger is a custom event your app sends. Create one for signups:

```typescript
await reloop.automations.triggers.create({
  name: "User signed up",
  key: "user.signed_up",
  properties: [{ name: "plan", propertyType: "string", required: false }],
});
```

### 4. Build the automation

You can build this visually under **Automation** in the dashboard, or with the API. The logic is: send the welcome, then for each nudge wait, check `contact.activated_at`, and only send if it isn't set.

```typescript
const notActivated = {
  type: "rule",
  field: "contact.activated_at",
  operator: "not_exists",
} as const;

const { automation, automationError } = await reloop.automations.create({
  name: "Welcome sequence",
  status: "active",
  steps: [
    { key: "start", type: "trigger", config: { eventName: "user.signed_up" } },
    { key: "welcome", type: "send_email", config: { template: { id: "tmpl_welcome" } } },

    { key: "wait_1", type: "delay", config: { amount: 1, unit: "days" } },
    { key: "check_1", type: "condition", config: notActivated },
    { key: "blocker", type: "send_email", config: { template: { id: "tmpl_blocker" } } },

    { key: "wait_2", type: "delay", config: { amount: 2, unit: "days" } },
    { key: "check_2", type: "condition", config: notActivated },
    { key: "outcome", type: "send_email", config: { template: { id: "tmpl_outcome" } } },

    { key: "wait_3", type: "delay", config: { amount: 4, unit: "days" } },
    { key: "check_3", type: "condition", config: notActivated },
    { key: "human", type: "send_email", config: { template: { id: "tmpl_human" } } },

    { key: "wait_4", type: "delay", config: { amount: 7, unit: "days" } },
    { key: "check_4", type: "condition", config: notActivated },
    { key: "last", type: "send_email", config: { template: { id: "tmpl_last" } } },
  ],
  connections: [
    { from: "start", to: "welcome" },
    { from: "welcome", to: "wait_1" },
    { from: "wait_1", to: "check_1" },
    { from: "check_1", to: "blocker", type: "condition_met" },
    { from: "blocker", to: "wait_2" },
    { from: "wait_2", to: "check_2" },
    { from: "check_2", to: "outcome", type: "condition_met" },
    { from: "outcome", to: "wait_3" },
    { from: "wait_3", to: "check_3" },
    { from: "check_3", to: "human", type: "condition_met" },
    { from: "human", to: "wait_4" },
    { from: "wait_4", to: "check_4" },
    { from: "check_4", to: "last", type: "condition_met" },
  ],
});
```

When a condition doesn't match (the user has activated), that path has no next step, so the contact simply finishes the automation. The delays add up to day 1, 3, 7 and 14.

### 5. Start it on signup

In your signup handler, track the event. Passing `email` creates the contact if it doesn't exist yet. If you [block disposable emails at signup](/blog/block-disposable-emails-at-signup), do that check first so the sequence isn't wasted on throwaway inboxes.

```typescript
const { automationError } = await reloop.automations.start({
  event: "user.signed_up",
  email: user.email,
  firstName: user.name,
  properties: { plan: user.plan },
});
if (automationError) console.error(automationError);
```

That's the whole integration: one call on signup, one call on activation.

<Callout type="info">
  By default a contact goes through an automation once, so signing up twice with the same email won't restart the sequence. Contacts who unsubscribe leave the automation at their next step.
</Callout>

### Branch by plan

Conditions can also read event properties. To send trial users a different welcome than paid users, add a condition on `trigger.plan` right after the trigger and point the Yes and No paths at different welcome templates.

---

## Measure what matters

Opens are a weak signal: Apple Mail Privacy Protection preloads images, so open rates overstate real reads. Measure the sequence by what it's for.

| Metric | How to get it |
|---|---|
| Activation rate | Users with `activated_at` set ÷ signups, by signup week |
| Time to activate | `activated_at` minus signup time |
| Where people stop | Enrollment history in the automation shows which step each contact reached |
| Clicks per email | Click tracking in Reloop's email logs |
| Replies to email 4 | Your support inbox |

Change one email at a time and compare activation for signup cohorts before and after. That's slower than A/B testing subject lines, but it measures the thing you care about.

---

## Common mistakes

| Mistake | Fix |
|---|---|
| Sending everyone every email | Check activation before each nudge |
| A tour of every feature | One action per email, all pointing to activation |
| `noreply@` sender | A person's name and a monitored `reply_to` |
| Sending from the transactional domain | Use a separate subdomain for onboarding |
| Never changing the sequence | Review it every quarter against activation data |
| Keeping going forever | Stop after two weeks; fix onboarding instead |

---

## FAQ

<AccordionGroup>
  <Accordion title="How many emails should a welcome sequence have?">
    Enough to cover the time it usually takes a user to activate, and no
    more. For most self-serve SaaS that's four to six emails over one to two
    weeks. If most users activate on day one, two or three emails are plenty.
  </Accordion>

  <Accordion title="Should the welcome email be transactional or marketing?">
    The first welcome email confirms an action the user just took, so many
    teams treat it as transactional. The follow-up nudges are promotional
    and need an unsubscribe link. When in doubt, include one in every email.
  </Accordion>

  <Accordion title="Can I edit the sequence after it's live?">
    Yes. Edits to an active automation are saved as a draft until you
    publish them. Contacts already in the sequence finish on the version they
    started with, and new signups get the new version.
  </Accordion>

  <Accordion title="How do I add existing users to a new sequence?">
    Enroll them directly with `reloop.automations.enroll(automationId,
    { email })`, without tracking the signup event again.
  </Accordion>
</AccordionGroup>

<Cta
  title="Build your welcome sequence"
  description="Triggers, delays and conditions in one automation, from the dashboard or the API."
  href="/docs/learn/workflows"
  label="Read the automations guide"
/>