SaaS onboarding email sequence with video demos and cost tracking

You've built a SaaS product. Now you need to onboard customers, but your current process is painful. You're manually sending emails, copying customer data into spreadsheets, recording video demos separately, and tracking burn rate by hand. Each step requires someone to sit down and do repetitive work. What should take minutes takes hours, and you're scaling poorly.

The real problem is that your onboarding tools don't talk to each other. Your email platform doesn't know about the video you created last week. Your cost tracking system is completely disconnected from your customer outreach. And when a prospect signs up, their data lives in three places, none of which automatically sync.

This workflow shows you how to build an automated onboarding sequence that runs while you sleep. When a new customer signs up, the system will immediately generate a personalised video demo, send a multi-part email sequence, and track their burn rate in real time, all without human intervention.

The Automated Workflow

The workflow consists of five core steps: a customer registration trigger, a video generation request, a sequence of automated emails with embedded demos, and continuous cost tracking. We'll use n8n as the orchestration tool because it offers robust local execution, excellent error handling, and strong API support for the tools we need....... For more on this, see Customer support ticket analysis and response automation. For more on this, see Multilingual customer support ticket automation with resp....

Here's how the data flows:

1. A new customer signs up (via webhook, form submission, or API call)
2. n8n captures this event and extracts the customer data
3. Hour One generates a personalised video demo with the customer's name and company details
4. ChatGPT Writer creates custom email copy for each stage of the sequence
5. Burnrate pulls live financial metrics for that customer
6. n8n orchestrates the entire sequence, timing emails and adding video links

Let's build this step by step.

Setting Up the n8n Workflow

Create a new n8n workflow. Start with a webhook node to receive customer registration data. This endpoint will be where your signup form or API sends the customer information.

Copy
POST /webhook/customer-signup
{
  "customer_id": "cust_12345",
  "customer_name": "Alice",
  "company_name": "Acme Ltd",
  "email": "alice@acme.com",
  "plan": "pro"
}

In n8n, add a Webhook trigger node. Set it to listen for POST requests. The webhook URL will look something like https://your-n8n-instance.com/webhook/customer-signup.

Generating Personalised Video Demos with Hour One

Hour One creates AI-generated videos from scripts. You can personalise videos with customer names and company details. Set up a second node in n8n to call the Hour One API.

You'll need your Hour One API key. Add a node of type "HTTP Request" in n8n.

Copy
POST https://api.hourone.com/v1/videos
{
  "api_key": "your_api_key_here",
  "script": "Hi {{ customer_name }}, welcome to our platform. I'm excited to show you how {{ company_name }} can benefit from Acme. Let me walk you through the key features.",
  "avatar": "professional_avatar_1",
  "background": "office_background",
  "variables": {
    "customer_name": "Alice",
    "company_name": "Acme Ltd"
  },
  "voice": "british_female"
}

In n8n, map the webhook input fields to the Hour One request. The customer_name field from the webhook should populate the script variable. Set this node to run immediately after the webhook triggers.

Hour One will respond with a video ID and a URL. The video generation takes a few minutes, so you have two options: poll the API repeatedly, or use a webhook callback. For this workflow, we'll use polling with a delay.

Add a "Wait" node set to 5 minutes, then add another HTTP Request node to check the video status:

Copy
GET https://api.hourone.com/v1/videos/{video_id}
{
  "api_key": "your_api_key_here"
}

When the status returns "completed", extract the video URL and store it in a variable for later use.

Creating Customised Email Copy with ChatGPT Writer

ChatGPT Writer generates email content. You'll create three emails: an initial welcome message, a features deep-dive, and a pricing summary. Each email should reference the personalised video.

Add an HTTP Request node to call the ChatGPT API (or use ChatGPT Writer's API if available). Here's the request for the first email:

Copy
POST https://api.openai.com/v1/chat/completions
{
  "model": "gpt-4",
  "messages": [
    {
      "role": "system",
      "content": "You are an onboarding specialist writing SaaS welcome emails."
    },
    {
      "role": "user",
      "content": "Write a friendly welcome email for {{ customer_name }} at {{ company_name }}. They just signed up for the {{ plan }} plan. Keep it under 150 words. Mention that a personalised video demo is attached."
    }
  ],
  "temperature": 0.7
}

Extract the email content from the response. Repeat this node twice more with different prompts for the second and third emails in the sequence.

Fetching Financial Data from Burnrate

Burnrate tracks customer spend and usage metrics. Call the Burnrate API to get the customer's current burn rate, projected runway, and spend forecast:

Copy
GET https://api.burnrate.io/v1/customers/{customer_id}
{
  "api_key": "your_api_key_here"
}

This call returns metrics like monthly burn rate, remaining runway, and cost per feature. Store these values in n8n variables so you can reference them in the final email.

Orchestrating the Email Sequence with Delays

Now you need to send the three emails with proper timing. Most SaaS onboarding sequences space emails over several days. We'll send email 1 immediately, email 2 after 2 days, and email 3 after 5 days.

Add an "Email" node in n8n (or use an HTTP Request to call your email provider's API). Configure the first email:

Copy
POST https://api.sendgrid.com/v3/mail/send
{
  "personalizations": [
    {
      "to": [
        {
          "email": "{{ webhook.body.email }}"
        }
      ],
      "subject": "Welcome to Acme, {{ webhook.body.customer_name }}!"
    }
  ],
  "from": {
    "email": "onboarding@acme.com",
    "name": "Acme Onboarding"
  },
  "content": [
    {
      "type": "text/html",
      "value": "<h1>Welcome to Acme</h1><p>{{ chatgpt_response_1.content }}</p><p><a href='{{ hour_one.video_url }}'>Watch your personalised demo</a></p>"
    }
  ]
}

After the first email is sent, add a "Wait" node for 2 days (172800 seconds):

Copy
Wait 172800 seconds

Then send the second email with the deep-dive content and the burnrate metrics embedded:

Copy
POST https://api.sendgrid.com/v3/mail/send
{
  "personalizations": [
    {
      "to": [
        {
          "email": "{{ webhook.body.email }}"
        }
      ],
      "subject": "Your ROI potential: {{ customer_name }}"
    }
  ],
  "from": {
    "email": "onboarding@acme.com",
    "name": "Acme Onboarding"
  },
  "content": [
    {
      "type": "text/html",
      "value": "<h1>How Acme delivers ROI</h1><p>{{ chatgpt_response_2.content }}</p><p>Based on your usage, your projected savings: £{{ burnrate.monthly_savings }}</p>"
    }
  ]
}

Add another "Wait" node for 3 days (259200 seconds), then send the final email:

Copy
POST https://api.sendgrid.com/v3/mail/send
{
  "personalizations": [
    {
      "to": [
        {
          "email": "{{ webhook.body.email }}"
        }
      ],
      "subject": "Complete your onboarding: pricing and next steps"
    }
  ],
  "from": {
    "email": "onboarding@acme.com",
    "name": "Acme Onboarding"
  },
  "content": [
    {
      "type": "text/html",
      "value": "<h1>Your pricing summary</h1><p>{{ chatgpt_response_3.content }}</p><p>Your monthly burn rate: £{{ burnrate.monthly_burn_rate }}<br/>Remaining runway: {{ burnrate.runway_months }} months</p><p><a href='https://app.acme.com/setup'>Complete setup</a></p>"
    }
  ]
}

Continuous Cost Tracking

After the sequence completes, set up a recurring n8n workflow to pull updated burnrate data daily. This keeps your cost tracking current without manual effort.

Create a new workflow with a "Schedule" trigger set to run daily at 9 AM:

Copy
Interval: 1 day

For each active customer in your database, call the Burnrate API and log the results to a spreadsheet or database:

Copy
GET https://api.burnrate.io/v1/customers/{customer_id}/metrics
{
  "api_key": "your_api_key_here",
  "date": "{{ today }}"
}

Store the response in a Google Sheets, Airtable, or database record. This gives you a historical cost tracking record without any manual data entry.

The Manual Alternative

If you prefer more control over each step, you can run this workflow semi-manually. Generate videos in Hour One's web interface, write emails in ChatGPT directly, and send them through your email platform by hand. This gives you full editorial control but loses the automation benefits.

For most teams, the manual approach is fine if customer volume is low (under 5 per month). Once you hit 10+ signups per month, the automation pays for itself in time savings.

If you want partial automation, you can automate just the video generation and email sending, whilst manually writing the copy. This is a reasonable middle ground.

Pro Tips

1. Handle Hour One Video Delays Gracefully. Hour One videos sometimes take longer than expected. Don't hold up your email sequence waiting for the video. Instead, send the first email immediately with a placeholder message like "Your personalised video will arrive within the next hour". When the video completes, send a follow-up email with the video link. This keeps the sequence momentum going.

2. Validate Email Addresses Before Sending. Add a validation step in n8n to check email format. If the address is invalid, trigger a Slack notification so a human can follow up manually. This prevents bounces and keeps your sender reputation clean.

Copy
POST https://api.hunter.io/v2/email-verifier
{
  "domain": "{{ extract_domain_from_email }}",
  "email": "{{ webhook.body.email }}",
  "api_key": "your_api_key_here"
}

3. Respect Rate Limits on All APIs. Hour One allows 10 videos per minute. ChatGPT has rate limits based on your plan. Burnrate limits requests to 100 per hour. If you exceed these, add exponential backoff retry logic in n8n. Set up error handling nodes that catch rate limit errors (HTTP 429) and retry after waiting.

4. Store Workflow Execution Logs for Debugging. Enable logging in n8n and store execution details. When something fails, you'll know exactly where. Log each step: webhook received, video created, emails sent, burnrate data fetched. This makes troubleshooting much faster.

5. A/B Test Email Subject Lines and Video Styles. Run two versions of this workflow; one for customers with subject line A and one with subject line B. Track open rates in your email platform. Similarly, test different avatar styles and backgrounds in Hour One. Measure which converts better to paid sign-ups.

6. Add a Manual Override for High-Value Prospects. If a prospect spends more than £1000 in their first week, trigger a Slack message to your sales team asking if they should call instead of relying on email. Use a conditional node in n8n to check burnrate thresholds.

Copy
IF burnrate.weekly_spend > 1000
THEN send_slack_message("High-value prospect alert: {{ customer_name }}")

Cost Breakdown

For early-stage teams, the total cost sits around £250 per month. For 50 customers onboarded, that's about £5 per customer. Compare this to manually onboarding, which costs time from multiple team members.

If you hit limits, scale incrementally. Move from SendGrid Essential to Standard at £100/month when you exceed 15,000 emails. Upgrade Hour One to the Premium plan at £299/month when you need 100+ videos monthly. Both upgrades are linear with customer volume, not exponential.

This workflow is intermediate in difficulty because it requires wiring together five different APIs and managing timing and error handling. Start with the video generation and email sending, then add burnrate tracking later once you have the core sequence running smoothly.