SaaS onboarding email sequence with video demos and cost tracking

Introduction

SaaS onboarding is broken. You spend weeks designing the perfect first impression, crafting compelling emails, filming product demos, and building customer success metrics. Then it falls apart at the handoff. Your marketing automation sends an email, but nobody connects it to the video demo platform. Your finance team tracks costs separately in a spreadsheet. Your customer success team waits three days for reports. The new customer sits in limbo, watching their trial clock tick down.

The reason this happens is straightforward: onboarding involves too many different systems. You need email delivery, video generation, cost calculations, and analytics all talking to each other. Most teams handle this with manual work, running queries, copying data, and sending follow-up messages by hand. It works, but it costs time and introduces errors at every step.

This workflow eliminates those handoffs. We'll wire together ChatGPT Writer for personalised email generation, Hour One for dynamic video creation, Burnrate for cost tracking, and an orchestration layer that keeps everything in sync. When a new customer signs up, the entire sequence runs on its own: their onboarding email goes out with a custom video demo, cost data flows into your tracking system, and you get a complete picture of their journey without touching anything.

The Automated Workflow

This workflow works best with Make (Integromat) as your orchestration tool. Make handles multi-step workflows well, has good error handling for third-party APIs, and doesn't require you to deploy code. If you prefer n8n, the logic translates directly, just with different module names. Zapier works too, though you'll hit rate limits sooner on the free plan.

Here's the flow:

1. Customer signs up (via form webhook, CRM, or API call)
2. Fetch customer data (company size, plan tier, trial length)
3. Generate personalised onboarding email with ChatGPT Writer
4. Create custom video demo with Hour One
5. Log costs to Burnrate
6. Send email with video link embedded
7. Store entire record in your database or CRM

Let's build this step by step.

Step 1:

Set up the webhook trigger

Your orchestration workflow starts when a new customer signs up. This can come from a form, your API, Stripe, or your CRM. In Make, create a Custom Webhook module:

Copy
Webhook URL (provided by Make):
https://hook.integromat.com/xxxxx/xxxxx/yyyyy

Expected data structure:
{
  "customer_id": "cust_12345",
  "email": "alice@company.com",
  "company_name": "Acme Corp",
  "plan_tier": "professional",
  "trial_days": 14,
  "industry": "SaaS"
}

Set your form or API to POST to this URL when a new customer registers. Make will wait for incoming data, parse it, and pass it to the next step.

Step 2:

Fetch enriched customer data

Before generating emails and videos, pull additional context. If you store customer data in your database or CRM, use an HTTP module to retrieve it. For example, querying your own API:

Copy
GET /api/customers/{customer_id}

Response structure:
{
  "customer_id": "cust_12345",
  "email": "alice@company.com",
  "company_name": "Acme Corp",
  "plan_tier": "professional",
  "trial_days": 14,
  "industry": "SaaS",
  "estimated_monthly_cost": 299,
  "key_features": ["analytics", "custom_integrations", "team_collaboration"],
  "account_manager": "bob@yourcompany.com"
}

Map this response data to variables in Make so you can reference it in later steps. If using n8n, you'd use the HTTP Request node with similar mapping.

Step 3:

Generate personalised onboarding email with ChatGPT Writer

ChatGPT Writer doesn't have a direct API, but you can use OpenAI's API directly to generate email copy, then integrate it with ChatGPT Writer's interface for final edits if needed. For this workflow, we'll call the OpenAI API to generate the email body.

Set up an HTTP POST request to OpenAI:

Copy
POST https://api.openai.com/v1/chat/completions
Authorization: Bearer sk-YOUR_OPENAI_KEY

{
  "model": "gpt-4",
  "temperature": 0.7,
  "messages": [
    {
      "role": "system",
      "content": "You are a SaaS customer success specialist writing onboarding emails. Be warm, specific, and action-oriented. Keep emails under 150 words."
    },
    {
      "role": "user",
      "content": "Write an onboarding email for {{company_name}}, a {{industry}} company on our {{plan_tier}} plan. Key features they'll use: {{key_features}}. Their trial is {{trial_days}} days. The account manager is {{account_manager}}. Personalise it and include a call-to-action to watch their custom demo video."
    }
  ]
}

Extract the email body from the response:

Copy
{
  "choices": [
    {
      "message": {
        "content": "Hi Alice,\n\nWelcome to Acme Analytics. We're thrilled to have you try our platform with a focus on the analytics, custom integrations, and team collaboration features that matter most to Acme Corp.\n\nBob will be your guide for the next 14 days. He's put together a custom demo video showing exactly how your team can set up dashboards in minutes.\n\nWatch your demo here: [link]\n\nReady to dive in?\nThe Team"
      }
    }
  ]
}

Store this response in a variable (e.g., email_body).

Step 4:

Create a custom video demo with Hour One

Hour One creates video presentations featuring an AI avatar. You'll call their API to generate a video tailored to this customer.

Register for an Hour One account, grab your API key, and call their video generation endpoint:

Copy
POST https://api.hourone.com/api/videos
Authorization: Bearer YOUR_HOUR_ONE_API_KEY
Content-Type: application/json

{
  "script": "Hello {{customer_first_name}}, welcome to our platform. As a {{industry}} company, you'll benefit most from three features. First, real-time analytics dashboards. Second, seamless integration with your existing tools. Third, team collaboration across departments. Let me show you how to set up your first dashboard in under five minutes.",
  "avatar_id": "standard_female",
  "voice": "en-US-Neural2-C",
  "duration": 120,
  "title": "{{company_name}} - Custom Product Demo",
  "metadata": {
    "customer_id": "{{customer_id}}",
    "plan_tier": "{{plan_tier}}"
  }
}

This returns a video ID and processing status:

Copy
{
  "id": "video_abc123def456",
  "status": "processing",
  "created_at": "2024-01-15T10:30:00Z",
  "estimated_completion": "2024-01-15T10:45:00Z",
  "preview_url": "https://preview.hourone.com/abc123def456"
}

Store the id and preview_url. In Make, add a delay module to wait 15 minutes, then check if the video is ready by polling the status endpoint:

Copy
GET https://api.hourone.com/api/videos/{{video_id}}/status
Authorization: Bearer YOUR_HOUR_ONE_API_KEY

Response:
{
  "id": "video_abc123def456",
  "status": "ready",
  "video_url": "https://videos.hourone.com/abc123def456.mp4",
  "thumbnail_url": "https://videos.hourone.com/abc123def456_thumb.jpg"
}

Once the status is "ready", proceed to send the email.

Step 5:

Log costs to Burnrate

Burnrate tracks your software spend. Now that you know which plan tier this customer is on, log the recurring cost. Use their API:

Copy
POST https://api.burnrate.app/api/costs
Authorization: Bearer YOUR_BURNRATE_API_KEY
Content-Type: application/json

{
  "customer_id": "{{customer_id}}",
  "company_name": "{{company_name}}",
  "plan_name": "{{plan_tier}}",
  "monthly_cost": {{estimated_monthly_cost}},
  "billing_cycle": "monthly",
  "start_date": "2024-01-15",
  "end_date": "2024-01-15T14:00:00Z",
  "tags": ["onboarding", "trial"],
  "metadata": {
    "industry": "{{industry}}",
    "account_manager": "{{account_manager}}"
  }
}

Burnrate returns a confirmation:

Copy
{
  "id": "cost_xyz789",
  "status": "logged",
  "monthly_cost": 299,
  "annual_projection": 3588
}

This gives your finance team real-time visibility into new customer commitments.

Step 6:

Send the email with video embedded

Now send the onboarding email with the video link. Use your email service (SendGrid, Mailgun, or your CRM's email module):

Copy
POST https://api.sendgrid.com/v3/mail/send
Authorization: Bearer YOUR_SENDGRID_API_KEY
Content-Type: application/json

{
  "personalizations": [
    {
      "to": [
        {
          "email": "{{email}}"
        }
      ],
      "dynamic_template_data": {
        "customer_name": "{{customer_first_name}}",
        "company_name": "{{company_name}}",
        "email_body": "{{email_body}}",
        "video_url": "{{video_url}}",
        "video_thumbnail": "{{thumbnail_url}}",
        "account_manager": "{{account_manager}}",
        "account_manager_email": "{{account_manager_email}}",
        "trial_days": "{{trial_days}}"
      }
    }
  ],
  "from": {
    "email": "onboarding@yourcompany.com",
    "name": "Your Company Onboarding"
  },
  "template_id": "d-your_template_id"
}

Use a SendGrid dynamic template that includes an embedded video player or CTA button pointing to your video. The template might look like:

Copy
Subject: Welcome to {{company_name}} — your custom demo is ready

Hi {{customer_name}},

{{email_body}}

[Watch your custom demo]
{{video_url}}

Questions? Reach out to {{account_manager}} at {{account_manager_email}}.

Best,
The Team

SendGrid returns a message ID:

Copy
{
  "message_id": "msg_sendgrid_abc123"
}

Step 7:

Store the complete record

Create a final record in your database or CRM documenting the entire onboarding sequence:

Copy
POST /api/onboarding_sessions
Content-Type: application/json

{
  "customer_id": "{{customer_id}}",
  "email": "{{email}}",
  "company_name": "{{company_name}}",
  "plan_tier": "{{plan_tier}}",
  "trial_days": "{{trial_days}}",
  "triggered_at": "2024-01-15T10:00:00Z",
  "email_generated_by": "openai_gpt4",
  "email_body": "{{email_body}}",
  "email_sent_at": "2024-01-15T10:35:00Z",
  "email_message_id": "{{sendgrid_message_id}}",
  "video_id": "{{video_id}}",
  "video_url": "{{video_url}}",
  "video_created_at": "2024-01-15T10:45:00Z",
  "cost_logged": true,
  "cost_id": "{{burnrate_cost_id}}",
  "monthly_cost": "{{estimated_monthly_cost}}",
  "workflow_status": "completed"
}

This gives you a complete audit trail. You can query this later to understand which customers watched their demos, when they signed up, and how much they cost you to acquire.

Orchestration Tool Configuration in Make

In Make, your workflow looks like this:

1. Custom Webhook trigger
2. HTTP module: Fetch customer data
3. HTTP module: Call OpenAI to generate email
4. HTTP module: Call Hour One to create video
5. Wait module: 15 minute delay
6. HTTP module: Poll Hour One status
7. HTTP module: POST to Burnrate
8. HTTP module: Send email via SendGrid
9. HTTP module: Log record to your database

Connect each module's output to the next step's input using the variable mapping interface. Make handles most of the data flow automatically, but you'll need to manually map certain fields (like customer_id or email_body) when moving between steps.

For n8n, the structure is nearly identical: use HTTP Request nodes instead of HTTP modules, and the Webhook node instead of Custom Webhook.

The Manual Alternative

If you prefer more control over each step, you can orchestrate this with Claude Code. Write a Python script that:

1. Listens for a webhook from your form
2. Calls each API in sequence
3. Handles retries and errors
4. Logs everything to a file

Here's a skeleton:

Copyimport requests
import json
import time
from datetime import datetime

def generate_onboarding_flow(customer_data):
    # Extract customer info
    customer_id = customer_data['customer_id']
    email = customer_data['email']
    company = customer_data['company_name']
    
    # Step 1: Generate email
    email_body = call_openai(
        f"Write onboarding email for {company}"
    )
    print(f"Email generated for {customer_id}")
    
    # Step 2: Create video
    video_id = call_hour_one(
        script=f"Hello, welcome {company}..."
    )
    print(f"Video creation started: {video_id}")
    
    # Step 3: Wait for video
    time.sleep(900)  # 15 minutes
    video_url = poll_hour_one_status(video_id)
    print(f"Video ready: {video_url}")
    
    # Step 4: Log cost
    cost_id = call_burnrate(
        customer_id=customer_id,
        monthly_cost=customer_data['estimated_monthly_cost']
    )
    print(f"Cost logged: {cost_id}")
    
    # Step 5: Send email
    message_id = call_sendgrid(
        email=email,
        body=email_body,
        video_url=video_url
    )
    print(f"Email sent: {message_id}")
    
    # Step 6: Store record
    store_onboarding_record({
        "customer_id": customer_id,
        "email_body": email_body,
        "video_id": video_id,
        "video_url": video_url,
        "cost_id": cost_id,
        "message_id": message_id,
        "completed_at": datetime.now().isoformat()
    })

def call_openai(prompt):
    response = requests.post(
        "https://api.openai.com/v1/chat/completions",
        headers={"Authorization": f"Bearer {OPENAI_KEY}"},
        json={
            "model": "gpt-4",
            "messages": [{"role": "user", "content": prompt}]
        }
    )
    return response.json()['choices'][0]['message']['content']

def call_hour_one(script):
    response = requests.post(
        "https://api.hourone.com/api/videos",
        headers={"Authorization": f"Bearer {HOUR_ONE_KEY}"},
        json={"script": script, "avatar_id": "standard_female"}
    )
    return response.json()['id']

This approach requires hosting, but gives you total visibility and control. It's best for teams with engineering resources.

Pro Tips

Handle video creation delays gracefully. Hour One typically takes 10 to 20 minutes to render a video. Don't block your entire workflow waiting. Instead, use a polling pattern: check status every two minutes, and if it's not ready after 25 minutes, log it to a backlog and have a manual team follow up. This prevents timeouts.

Implement retry logic for API calls. Network glitches happen. In Make, use the error handler module after each HTTP call to retry failed requests up to three times with exponential backoff (wait 2 seconds, then 4, then 8). This is especially important for the email send step; a failed onboarding email is worse than a delayed one.

Monitor token usage and costs. ChatGPT Writer and OpenAI charge per token. An onboarding email might use 200 to 300 tokens. With 100 new customers per month, that's roughly 2,000 to 3,000 tokens, or around $0.03 at GPT-3.5 rates. Still cheap, but keep an eye on it. In Make, add a logging step that records token counts so you can forecast spending.

Test with yourself first. Before running this on real customers, trigger the workflow with your own email address. Verify the email arrives, the video is actually generated, and the links work. A broken onboarding sequence is actively harmful; it makes customers doubt your company.

Customise the video script per plan tier. Professional plan customers should see different feature highlights than Starter tier customers. When building the Hour One script, include conditional logic in your ChatGPT prompt: "For {{plan_tier}} plans, emphasise these features: {{key_features}}." This makes demos feel more relevant and increases watch-through rates.

Cost Breakdown

The big variable is Hour One. If you're sending >100 onboarding videos per month, their Standard plan gets expensive. Consider generating videos asynchronously (send email first, create video in background, follow up when ready) or capping video generation to your top-tier customers only.

Conclusion

This workflow removes the friction from SaaS onboarding. No spreadsheets, no manual hand-offs, no delays. A customer signs up on Monday morning, and by Tuesday they have a personalised email and a custom video waiting for them. Your cost tracker knows about it. Your team has a complete record.

The orchestration layer is simple enough to set up in an afternoon, and the payoff compounds. Every new customer goes through the same high-quality sequence. You collect better data. Your finance team reports accurate costs. Your customer success team closes gaps faster.

Start with Make if you want no-code simplicity. Upgrade to n8n if you need more flexibility. Use Claude Code if you have engineering support and want total control. All three approaches work; pick the one that fits your team's skills.