A personal onboarding video for every signup, at 25 cents each
Signup data → script merged, rendered, voiced → a walkthrough in the welcome email
Onboarding was one twelve-minute demo recorded eighteen months earlier, against a UI that had moved on twice since. Most signups never finished it, and the ones who did asked support the same setup questions anyway. Now every account gets its own ninety-second video: their workspace name, their plan, and the three steps that matter for the use case they picked at signup. Creatomate renders it from an approved template, so a product change is a template edit rather than twelve re-records. About 600 videos a month, at roughly 25 cents each.
What it's worth
What the same video set costs to buy
- Videos in the set (4 use cases × 3 plans)
- 12
- Freelance editor rate
- $75 / hr
- Time to script, capture, edit, and voice one
- ~4 hrs
- Cost per finished video
- ~$300
- Refreshes a year to keep pace with the product
- 4
- Videos produced per year
- 48
- per year
- ~$14,400
Support time back
- Setup questions per month, before
- ~240
- Setup questions per month, after
- ~150
- Questions avoided per month
- 90
- Handling time per question
- ~12 min
- Hours back per year
- ~216 hrs
- Support agent cost
- $25 / hr
- per year
- $5,400
What the system costs to run
- Videos rendered per month
- ~600
- Creatomate rendering
- ~$72 / mo
- Voice synthesis
- ~$30 / mo
- Storage and delivery
- ~$25 / mo
- Orchestration and hosting
- ~$20 / mo
- Cost per video
- ~$0.25
- Running cost per year
- ~$1,760
- per year
- ~$1,760
How this was calculated — every assumption
- The production side is a cost-of-alternative benchmark, not money off an existing bill. The company paid an editor for the original demo once and then stopped refreshing it, because refreshing it cost more than living with it. So $14,400 is what keeping the set current would have cost, not a line removed from a budget.
- Editor time is priced at $75/hour and about four hours for a finished 90-second video, covering script, screen capture, edit, voice, and one round of review. Four refreshes a year matches the release cadence that made the old demo stale in the first place.
- Setup question volumes come from the helpdesk's own tags, over the three months either side of launch. About 12 minutes of handling time per question is the team's own average across first reply and follow-ups.
- Support time is costed at $25/hour, at the low end of a loaded agent cost.
- Running cost is metered, not estimated: rendering, voice, storage, delivery, and orchestration come to about $147 a month at 600 videos. It scales with signups, so a bigger month costs more.
- Per-account personalization is not priced at all. Nobody was going to hand-cut 600 videos a month, so there is no alternative to cost it against. It sits on the benefit side of the ledger.
- Nothing is claimed about activation, conversion, or retention. Those are the numbers a product team cares about most, and the ones this is most likely to have moved, but no clean before-and-after was measured, so no figure appears here.
Results at a glance
- ~$18,000 a year, after what the system costs to run
- About 600 personalized onboarding videos a month, at ~$0.25 each
- Setup questions down about 90 a month
- A product change is a template edit, not twelve re-records
- Video in the welcome email within minutes of signup, with their workspace in it
- Every render logged against the template version that produced it
The problem
New accounts got one twelve-minute demo recorded a year and a half earlier. The product had shipped two rounds of UI changes since, so the video showed screens that no longer existed. Most signups stopped watching in the first minute, and the ones who watched it through still opened a ticket asking how to connect their data. The company knew the fix was shorter videos, cut per use case and per plan, kept current with the product. They had priced it and shelved it. Twelve videos re-cut every quarter is a standing bill and a standing coordination job, and it still would not have said the customer's name or shown the workspace they had just created. The generic demo was not failing because it was long. It was failing because it was about the product in general and not about the account that had just signed up.
What was built
What goes in the video
Pulled from the account itself: first name, workspace name, plan tier, the use case picked during signup, whether teammates were invited, and which integration was connected first. Everything the video says is something the account already told the product.
Templates, not renders
One Creatomate template per use case, built once, with slots for the merged fields and the screen captures. The template is the thing that gets maintained. Every video is an output of it, so there is nothing to re-edit twelve times.
Script written once, per use case
Copy is written and approved by the product team, with merge fields where the account details go. No model writes product instructions per customer. A confident wrong step in a video is worse than no video.
Voice
The track is synthesized per video with ElevenLabs, so the names and workspace land in the cadence of the sentence rather than sounding dubbed in.
Rendering
n8n calls Creatomate when an account finishes signup and logs in for the first time. A 90-second video comes back in well under a minute, gets stored, and the link is written back onto the customer record.
Delivery
The link goes into the Customer.io welcome email and into the app's empty state, with a thumbnail showing their own workspace. It looks like it was made for them because it was.
When the product changes
A release that touches an onboarding screen flags the affected templates. New captures go in once, and the next render picks them up. Existing links keep working and are never silently swapped.
Logging
Every render is logged with the template version that produced it, the fields it merged, and how far the account watched. When a step changes, it is possible to say exactly which customers saw the old one.
What keeps it from breaking
Nothing renders from data it cannot trust
Missing names, placeholder workspaces, and test accounts fall back to the generic cut. A video that opens with "Hi , welcome to " is worse than the stale demo it replaced.
The script is approved, not generated
Product instructions are written by people and reviewed before they go in a template. Personalization only touches the fields around them.
A failed render never holds up the welcome email
If a render fails or runs long, the welcome email sends on time with the generic video, and the personalized one follows when it lands. Onboarding timing matters more than onboarding polish.
Video links are unguessable and scoped
The video contains a customer's workspace name, so the URL is signed and not enumerable. A personalized asset on a public, sequential URL is a data leak with a play button on it.
Templates are versioned
Every render records its template version. Without that, a wrong step in an old template is impossible to trace back to the accounts that were shown it.
How the approach worked
Rendering a video from a template is the easy part, and Creatomate does it for a fraction of a cent per second. The work is everywhere either side of that: deciding what the video is allowed to say, pulling the account details that make it worth watching, catching the cases where those details are missing, and making a product change cost one template edit instead of twelve re-records. The old demo was not too long. It was about the product instead of about the customer, and it was stale because keeping it fresh was a person's job. Move it onto templates and both problems go away at once.
The results
Every new account now gets its own video within minutes of signing up, built from the details it just gave the product. About 600 render a month at roughly 25 cents each. Setup questions dropped by about 90 a month against the helpdesk's own tags, worth around $5,400 a year of agent time. Keeping the set current stopped being a quarterly production job: a UI change is a new capture in a template, and the next render has it. Whether it moved activation or retention was never cleanly measured, so nothing is claimed about it here.
One twelve-minute demo against a UI that had changed twice. Most people stopped in the first minute, and the ones who did not still asked support how to connect their data.
A ninety-second video per account, with their workspace in it, in the welcome email within minutes. A product change is a template edit.
Tools & technologies
Have a process like this slowing your business down? Tell me your stack and goals and I'll send back a build plan.
Take the stack assessment →