Video Script & Storyboard
Write product videos the way strong software teams actually ship them: one clear change, one believable proof sequence, one visual logic, one next step - then convert each beat into a production-ready storyboard a motion designer can build immediately.
Do not write a generic brand ad with UI pasted into it. Do not write a feature list with cinematic adjectives. Make the viewer understand what changed, why it matters, and what to do next - then hand off a storyboard that says exactly how each scene looks, reads, and moves.
The output is a single document with two layers:
- Script layer - the argument, proof sequence, and copy (governed by the launch discipline below).
- Storyboard layer - scene cards with visuals, on-screen copy, voiceover, timing, psychology, and motion notes. When the cut mixes real footage, screen recording, designed graphics, and generated clips, tag each scene with one of those four sources and a slot id so an editor can drop media in later.
Communicating with the user
Before you write, get the launch shape clear. Ask for the things that change the script:
- What exactly is launching (new product, or a new feature of an existing one)?
- Who is this for right now?
- Where will the video live: homepage hero, launch page, keynote, social cutdown, paid ad, app store, investor update?
- What can the page or campaign carry outside the video?
- What is the single action after viewing: try it, learn more, sign up, book demo, watch keynote, read docs?
- What proof do you actually have: UI, workflow, result, customer, data point, live demo, before/after?
- What should the piece feel like: restrained, premium, technical, playful, urgent, calm?
- Aspect ratio(s): 16:9, 9:16, 1:1? (Decide early - it changes framing and text placement.)
If the user hands you a bloated list of features, push back. A hero launch video is not the place to dump the whole roadmap. Suggest splitting into a teaser, hero film, deeper demo, release post, or multiple modules.
If they ask for "Apple-style" or "Stripe-style," translate that into structure, not mimicry. Apple means immediate changed reality and clean product modules. Stripe means you can open on category stakes for technical products, but you need concrete proof almost immediately.
Prefer one audience and one primary CTA. If the launch serves multiple audiences, let the page handle branching.
If a missing detail changes the creative direction, ask up to three questions. Otherwise state assumptions and proceed.
Step 1 - Choose the launch architecture and framework
Decide what job this video is doing, then pick a framework that fits its length and goal.
Video job (rough split):
- Hero launch film: make the case fast; the page carries detail.
- Deeper demo: walk the workflow and answer more objections.
- Teaser: create intrigue; do not try to explain everything.
- Keynote segment: you can spend a few more beats on stakes, but each added minute needs a fresh proof module.
- Release/feature clip: one update, one payoff, one handoff to notes or product.
Framework by duration and objective:
| Framework | Best for | Duration | Structure |
|---|---|---|---|
| Hook-CTA | Social ads | 15-30s | Problem → Solution → CTA |
| PAS | Cold traffic | 30-90s | Problem → Agitation → Solution |
| AIDA | Product demos / feature launches | 60-120s | Attention → Interest → Desire → Action |
| The Explainer | Education-first | 60-180s | Context → How it works → Benefits → CTA |
| VSL Classic | Sales pages | 3-10min | Story → Problem → Solution → Proof → Offer → CTA |
Length guidelines:
| Duration | Type | Goal |
|---|---|---|
| 6-15s | Micro-content | Awareness, virality |
| 15-30s | Social ads | Traffic, interest |
| 30-60s | Product/feature teasers | Demo requests, clicks |
| 60-90s | Explainers | Understanding, watch time |
| 90-180s | Full demos | Trial signups |
| 3-10min | VSL sales videos | Purchase decisions |
Write the script for one job. A video gets flabby when it tries to be teaser, manifesto, full demo, and sales close at once. Default to shorter than the team wants - add runtime only when the idea is genuinely hard to visualize or each added section earns its place with a new proof module.
Step 2 - Choose the hook
The first 3-5 seconds determine most of the watch-through. Open on the changed reality, not on self-congratulation. Pick one hook on purpose:
- Blunt arrival / changed reality. Best when the brand already has attention. State what is here now ("GPT-5 is here").
- Pain → relief. Best for workflow products. Name the friction, then show the product removing it. ("Tired of [pain]?")
- Before/after tension. Best when the contrast is visual and immediate.
- Macro stakes → concrete demo. Best for infrastructure, fintech, AI, API launches. Open on the category shift, but cash it out in a visible transaction, command, or workflow within the first major beat.
- Symbolic / metaphor first. Only when the product is not yet showable or too abstract. Tie the metaphor back to the product fast.
- Demonstration / social-proof hook. Show an impressive result immediately, or lead with a specific number ("10,000 teams already ship this way").
Keep the opening sentence plain. Avoid "revolutionary," "game-changing," and similar filler unless the very next beat proves the claim in a visible way. Test the hook independently - it should work as a standalone ad.
Step 3 - Build the proof sequence
Organize the middle by proof modules, not feature-menu order. For each module write:
- Claim: what changed.
- Proof: the shot, workflow moment, output, metric, or demonstration that makes it believable.
- Implication: why the viewer should care.
Sequence by user task or outcome. A realistic workflow beats a feature checklist. Give each major claim room to land - one strong proof module beats three thin ones. If the product is technical or infrastructure-heavy, earn specificity early; don't stay at marketecture level for long.
Where conversion elements go (use only when honest and appropriate):
- Early social proof (15-25%): build credibility before big claims.
- Feature proof (40-60%): a testimonial or result after each key benefit.
- Final proof (80-90%): results-focused, right before the CTA.
Objection-handling order: Does it work? (demo + proof) → Will it work for me? (use cases) → Is it complicated? (show simplicity) → Is it worth it? (ROI / value) → What if it fails? (guarantee / risk reversal).
Lead with transformation, not features. Name the pain before the solution. Create urgency through value, not fake scarcity - never fake countdowns or false scarcity.
Step 4 - Write beats, visuals, pacing, and CTA
Think in beats, not paragraphs. Common beat types: context (what changed / what still hurts), product (the new capability), proof (live action, output, result), release (who gets it, what to do, where to go deeper).
Transitions should advance the argument, not decorate. Hard cut on a new claim. Overlap or bridge for continuity. Slow down briefly when the viewer must parse UI, code, or a result.
Visual grammar - keep it constrained: one product focus, one motion logic, one supporting art direction, one level of stylization. Keep the interface or concrete proof as the hero. Animate enough to clarify and elevate, never so much that the shipped product feels disappointing afterward.
On-screen text does one of four jobs: label the moment, frame the payoff, direct attention, punctuate the release. Never use it as a transcript of the voiceover. If the frame is busy, simplify the words; if the line is doing explanatory work, calm the frame. Plan for silent viewing (most watch without sound) - the story must read with text/visuals alone.
Voiceover (if used) is written in spoken thought-chunks. One sentence should buy one clear visual action, reveal, or payoff. Conversational over UI - documentation prose sounds stiff spoken. Let important moments breathe.
CTA: keep it simple and forward-moving. Default to one CTA after a completed proof sequence or at the end; let the page branch by audience/pricing/docs. Minimum two CTAs only for longer VSLs (a mid-point teaser once enough proof has landed, plus the final). Be specific ("Start free trial," not "Learn more") and remove friction ("No credit card" if true). If the CTA feels like an interruption, it's probably too early.
Step 5 - Produce the storyboard (the deliverable)
Convert the script into a document with these sections. Be concrete about what the viewer should understand and why the scene exists. Leave frame-by-frame execution to the motion designer or editor. If production needs a handoff, end with four lists: footage to shoot, generated-clip prompts, designed scenes, and screen recordings to capture.
1. Script header
# [Video Title]
**Type**: [Launch film / Feature reel / Explainer / Product Demo / Social Ad / VSL]
**Duration**: [Total seconds]
**Aspect ratio**: [16:9 / 9:16 / 1:1]
**Objective**: [Primary conversion goal]
**Target audience**: [Specific persona]
**Framework**: [AIDA / PAS / Hook-CTA / Explainer / VSL]
**Hook choice**: [Which hook and why]
## Key message
[Single sentence: what should viewers remember?]
## Desired action
[Specific CTA: what should viewers do?]
2. Story arc + emotional journey
## Story arc
Hook (0-Xs): [How we grab attention]
Build (Xs-Ys): [How we build interest/desire]
Peak (Ys-Zs): [Climax / main value proposition]
Close (Zs-End): [CTA and resolution]
## Emotional journey
Start: [Frustrated / Curious / Overwhelmed]
→ Middle: [Hopeful / Intrigued]
→ End: [Confident / Excited to act]
3. Scene-by-scene storyboard
Write one card per scene:
## Scene N: [Scene Name] (Xs-Ys, Duration: Zs)
**Narrative purpose**: [Why this scene exists - advances story AND conversion]
**On-screen copy**:
"[Exact text on screen]"
**Voiceover** (optional):
"[Exact words spoken]"
**Visual description**:
[What viewers see - specific enough to build, not to over-specify]
- Background / environment
- Main focal point (usually the product/proof)
- Supporting visuals
- Text treatment
**Viewer psychology**:
[Emotional state we create · objection handled (if any) · desire built]
**Proof / sales elements**:
[Claim→proof mapping · social proof · risk reversal · benefit emphasis - only if honest]
**Transition to next**:
[How this flows onward and why it advances the argument]
**Motion designer notes**:
[Pace (fast/slow), style (bold/subtle), key moments to emphasize, what to hold on]
4. Production requirements
## Assets needed
- [ ] Logo files
- [ ] Product screenshots / mockups / screen recordings
- [ ] Customer photos or quotes (if using testimonials)
- [ ] Data-viz elements, icons
- [ ] Music / VO direction
## Copy elements
- Headlines / subheads (list all)
- CTAs (list every instance)
- Social-proof quotes (list all, with source)
## Brand guidelines
- Voice: [Professional / Casual / Technical / Friendly]
- Tone: [Restrained / Premium / Urgent / Calm / Exciting]
- Restrictions: [Copy or visual rules, non-negotiables vs nice-to-haves]
Keep voiceover lines speakable, on-screen text short, and visual direction concrete. Mark invented metrics or demo names as placeholders. Provide visual direction, not technical specs - leave frame-by-frame execution to the motion designer.
Test the script and storyboard before handoff
Clarity and proof:
- Does the first beat make the new reality clear?
- Does each major claim get visible proof?
- Could a skeptical viewer explain what changed after one watch?
- Is the middle organized by workflow/outcome, not feature dumping?
- If you removed the brand logo, would the proof still feel specific to this product?
Pacing and copy density (read it out loud):
- One sentence trying to cover multiple visual actions?
- On-screen text repeating the voiceover?
- Big claims stacked on busy motion?
- No pause where the viewer needs to parse the interface?
- Runtime that grew without adding better proof?
- If a moment feels crowded, reduce one channel: fewer words, calmer motion, or less text.
CTA fit:
- Has the viewer seen enough proof before the CTA?
- Does the CTA feel like the next logical step?
- Is the film trying to segment audiences the page should segment?
Production readiness:
- Every scene has timing and duration.
- Visual descriptions are clear and specific.
- Assets are listed; motion-designer notes present; narrative purpose stated per scene.
- Format is ready for handoff without clarification.
If the answer to any clarity question is no, the script is still too generic.
Improving a weak draft
Tighten abstraction into evidence. Replace vague claims with a workflow step, an output, a visible before/after, a real command, a concrete artifact, a number with context, or a user result. "Powerful collaboration" is weak. "Review, comment, and ship from the same file" is stronger. Showing it happen is stronger still.
Cut informational pileup. Don't let macro thesis, dense narration, busy UI, and lots of labels hit at once. Pick the primary channel per beat: if the visual carries it, simplify the line; if the concept is abstract, calm the visual and let the line explain; if the payoff is new, pause long enough to register it.
Split one bloated film into multiple assets. Teaser for anticipation · hero film for the main case · deeper demo for understanding · release page/notes for detail · cutdowns for social/ads. Repeated launches usually beat one overbuilt mega-launch.
Anti-patterns
Script-level: opening on adjectives instead of a changed reality · brand manifesto with no proof · feature dumping (five features, two seconds each) · unclear or competing CTAs · all tell, no show · dishonest urgency (fake timers, false scarcity).
Scene-level: wall of text · orphaned scene that advances neither story nor conversion · no breathing room · inconsistent tone/voice between scenes · on-screen text repeating narration.
Production: vague visuals the motion designer must guess · missing scene timings · no assets list · animating the UI into something the shipped product can't match.
Examples
Example 1 - 60s feature/launch film, project-management app (pain → relief, AIDA).
Runtime target: 45-60s · Audience: product & engineering teams · Primary CTA: Try it free · Hook: pain → relief
Scene 1 - Hook (0-5s)
Visual: A plan splinters across chat, docs, and tickets.
On-screen: "Planning, scattered"
Voiceover: "Planning breaks when the work lives in three places."
Psychology: Immediate identification with pain.
Transition: Compress the chaos into one clean workspace.
Motion notes: Fast, fragmented cuts → snap to order.
Scene 2 - Changed reality (5-20s)
Visual: Collaborative planning view opens: roadmap, tasks, comments connected.
On-screen: "Collaborative planning"
Voiceover: "Now your roadmap, specs, and execution stay in one shared plan."
Proof element: Product beat - state the new capability.
Transition: Push into a real workflow.
Scene 3 - Proof (20-40s)
Visual: PM adjusts priorities; designer comments in context; engineer sees dependency shift instantly.
On-screen: "One update, everywhere it matters"
Voiceover: "Change scope once, and everyone sees it where they already work."
Psychology: Belief - the claim is now demonstrated.
Motion notes: Hold long enough to register the propagation.
Scene 4 - Payoff (40-52s)
Visual: Team ships a milestone; blockers clear; timeline tightens.
On-screen: "Faster decisions"
Voiceover: "Less status chasing. Faster decisions. Fewer surprises at launch."
Transition: Clean pullback into release frame.
Scene 5 - CTA (52-60s)
Visual: UI settles on the planning view; simple button treatment.
On-screen: "Try it free"
Voiceover: "Plan together from the first draft to the final ship."
Example 2 - 75s launch film, payments API for AI agents (macro stakes → concrete demo).
Runtime target: 60-75s · Audience: developers & product leaders · Primary CTA: Read docs · Hook: macro stakes → demo
Scene 1 - Missing step (0-10s)
Visual: Fast sequence of agent workflows hitting a wall at payment.
On-screen: "The missing step"
Voiceover: "AI agents can decide, compare, and act. Paying is still where they stop."
Motion notes: Cut immediately into the product - do not linger in abstraction.
Scene 2 - Setup (10-28s)
Visual: A developer adds one payments permission block in code.
On-screen: "Controlled agent payments"
Voiceover: "Give agents a spend limit, an approved merchant list, and a payment path in one flow."
Transition: Reveal the live transaction.
Scene 3 - Proof (28-48s)
Visual: Agent books a tool, hits approval rules, completes payment, returns receipt and log.
On-screen: "Policy built in"
Voiceover: "The agent makes the purchase, stays inside policy, and leaves a full audit trail."
Motion notes: Pause briefly on the receipt and controls.
Scene 4 - System trust (48-66s)
Visual: Dashboard shows limits, merchants, real-time controls updating.
On-screen: "Control every payment"
Voiceover: "You control where money moves, how much, and what happens next."
Transition: Pull from transaction detail to platform view.
Scene 5 - CTA (66-75s)
Visual: Docs page and API reference handoff.
On-screen: "Read docs"
Voiceover: "Build agent payments that can actually ship."
Expert tips
- Start with the CTA and work backwards - what journey gets them there?
- Write for the ear if using voiceover; test the hook as a standalone ad.
- One message per scene. Don't try to say everything everywhere.
- Use specific numbers ("10,000 customers," not "thousands").
- Plan for silent viewing and decide aspect ratio early.
- Budget ~30% longer than you think for final duration; leave room for motion-designer creativity.
- Reference other videos when helpful ("like X but for Y"); be clear about non-negotiables vs nice-to-haves.
Gotchas
- Do not open with "innovative," "powerful," or "revolutionary" unless the next beat proves it.
- Do not treat the product like a prop inside a brand ad.
- Do not write three sentences where one visible action would do more work.
- Do not let on-screen text repeat the narration word for word.
- Do not animate the UI into something the shipped product cannot match.
- Do not interrupt the viewer with a CTA before they understand the proof.
- Do not use fake urgency or scarcity.
- Do not stretch runtime unless each added section earns its place with a new proof module.
- Do not force one film to carry the whole launch if it really needs a campaign.
- Do not hand off vague visuals - every scene needs concrete direction, timing, and purpose.