vpv.

← Notes·2026-07-14·behind-the-video / build-video

How to film a hardware build video: the Hotline Claude example.

How to structure and shoot a hardware build video: order it by the project, keep the failures that changed the plan, and give the tech its own lane.

By updated 7 min read

Story pass and shot list: Planned in Vanpelt Studio →

A hardware build video is ordered by the project, not by the day: the promise, the first prototype, the obstacle that changes the plan, the moment it works, and an honest test where it can still fail. This note is for makers, developers and founders who want to film something they are building and have it hold attention for longer than a demo reel. The short answer: write the promise before you buy parts, keep every failure that changed your approach, and give the technical detail its own lane so the story never waits for it.

The worked example is my video The most absurd way to create a business, 11 minutes 40 seconds, published in February 2026. I turned a vintage phone into a voice line to a cloud coding agent: speak a request into the handset, a Raspberry Pi records it, Whisper transcribes it, and the agent pushes code to a live environment. What it built became marketistats.com. Every step below uses that video.

What are the six steps of a hardware build video?

  1. 01

    Write the promise in one sentence

    What the thing will do and why anyone should watch it get built. Output: one sentence you can say on camera in the first minute.

    Before you buy parts
  2. 02

    List the build stages as beats

    Prototype, first success, the likely obstacle, the final object, the real-world test. Output: a list of six to ten beats.

    15 min
  3. 03

    Give the tech its own lane

    Decide which details can be compressed into a visualizer or a chapter and which moments must land with no explanation. Output: a keep and compress list.

    15 min
  4. 04

    Shoot object, hands and screen at every stage

    Wide of the bench, close of the hands, the screen captured at source, a time marker. Output: four kinds of coverage per stage.

    Every session
  5. 05

    Log failures as they happen

    Tag each one: changed the plan, or just a delay. Output: a short failure log the edit can trust.

    2 min a day
  6. 06

    Test in public and cut to a verdict

    Use the thing where it can still break, then say what you think of it. Output: an ending that is a judgement, not a logo.

    Last shoot day
The method on one card. A plan for any build video, not a timecode log of this one.

Step 1: write the promise before you buy parts

The promise is one sentence that tells the viewer what will exist at the end and why the journey is worth eleven minutes. Write it first, because it decides what you film for the next week.

In the Hotline Claude video the promise takes the first 75 seconds: an AI running in the cloud that I prompt by speaking rather than typing, which pushes changes to a live development environment I can check from my phone anywhere. Then the twist that makes it a video rather than a tutorial: doing it with a smartphone would not be funny, so I bought an old phone (the video calls it a 1940s model) and built the whole thing into it.

Your output is the sentence plus the twist. If you cannot name the twist, the build is probably a tutorial, which is fine, but it wants a different structure (steps and chapters, no story arc). The video script guide has a template for this promise line.

Step 2: list the build stages, including the one that will go wrong

A vlog borrows its structure from life. A build borrows it from the project. That single difference changes what you shoot, what you keep and where the tension comes from.

A vlog

Structure comes from the day.

  • Chronological by default
  • Tension from what happens to you
  • Coverage: wherever you are
  • A smooth day is still watchable
  • The viewer is a companion

A build

Structure comes from the problem.

  • Ordered by the promise, the obstacle, the moment it works
  • Tension from whether the thing will function
  • Coverage: hands, screen and the object, legibly
  • A smooth build is an advert
  • The viewer is a witness
Why build footage cannot be cut like vlog footage, even when the same person shot both. A comparison of structures, not a rule about length.

How do you turn a project into a beat list?

So the beat list is a list of project stages, written before you film. For this video it read roughly: the lab, a working prototype, the first real prompt, the phone itself, a pitch, a test in the wild, a verdict. Leave a slot for the obstacle even though you do not know what it will be yet. Something always breaks, and the beat list should expect it.

Your output is six to ten beats. Each one should be a moment you could point a camera at, not a topic. "Explain the Raspberry Pi" is a topic. "Press the first button, watch the light come on and the volume bar move with my voice" is a beat, and it is the one the video actually uses at the four-hour mark.

Step 3: give engineers and everyone else their own lane

A build video has two audiences, and averaging them produces something slightly too slow for engineers and slightly too dense for everyone else. Separate the jobs instead.

The video does this bluntly. At 1:15 I say that most viewers probably do not care about the actual software, and the whole backend becomes a 30-second visualizer. The stages a non-developer can feel stay at full length: the light coming on when I press the button, the ls that shows a voice file on the Pi, the first spoken request (change the background colour to blue) arriving as a real change on a web page.

The rule I use: technical detail goes where it can be skipped without losing the thread, and the emotional beats are shot so they land with no explanation at all. YouTube chapters are the other tool for this. A chapter list needs a first timestamp at 00:00, at least three timestamps in ascending order, and chapters of at least 10 seconds, per YouTube's own help page, which is enough to give an engineer a door into the detail without making everyone walk through it.

Your output is a two-column list: compress (visualizer, chapter, voice-over) and keep whole (the moments of contact).

Where the 11 minutes 40 seconds of the cut went

The promise and the absurd idea 75 s
Software visualizer 30 s
The whole backend, compressed for viewers who do not code.
The lab and the first prototype 140 s
Raspberry Pi, breadboard, microphone, two buttons.
Whisper and the first working prompt 70 s
Bot attack and the security rebuild 45 s
Gutting and rebuilding the phone 100 s
Pitch to a potential investor 35 s
The pub test 125 s
Live prompts during a football match, and a failed signup.
The verdict 80 s
Approximate seconds per section of the published 11:40 cut, read from the caption timestamps. A map of the edit, not of how long each stage took to build.

Step 4: shoot the object, the hands and the screen

Builds demand coverage a vlog never needs. At every stage, get four things: a wide of the bench, close-ups of the hands, the screen, and a time marker.

The screen is where most build videos lose their audience, because a monitor filmed with a camera is unreadable at phone size. Capture it at source with a screen recorder instead. On a Mac that means anything built on Apple's ScreenCaptureKit, the same framework I later used for tvcast. Bump the terminal font before you record; it costs nothing and saves the shot.

Hands are the most reusable coverage you have: close, slow and well lit, they cut into almost any gap without breaking continuity. The object matters too. An old phone reads on camera instantly; a featureless black box has to invent its visual interest.

Time markers are the cheapest structure in the edit. The video uses plain cards ("Four hours later", "The next day") to show progress without narration. Your output per session is those four kinds of coverage, labelled by stage.

Step 5: keep the failures that changed the plan

Failure is where a build keeps its credibility. A build that goes smoothly for eleven minutes is a product demo wearing a documentary coat, and technical viewers detect it at once.

The rule: keep every failure that changed the approach, cut every failure that was just a delay. Three made the cut here. The original phone internals were not compatible, so instead of a restoration I kept only the hook mechanism on top to start and stop recording, added a small LED for feedback, and hid a send button at the back. Then a web bot scraped my data and tried to reach my environment variables, which cost me about a day of renewing keys and rebuilding from scratch. That one is my own mistake: I had a live environment reachable enough for a bot to find it while I was still prototyping. Finally, in the pub test, the signup flow failed because of a Supabase issue, on camera.

The bot attack is in the film because it changed the build (I spent the next afternoon on security before touching the phone). A loose wire that took ten minutes to find is not. Your output is a failure log with one tag per entry: changed the plan, or delay.

Step 6: test it where it can still fail, then give a verdict

The turn in this video is the ending. After the pub test, where the agent pushed a front end while everyone around me watched football, I say the setup felt like cheating, shut it down and finished the website on a laptop. A build video that ends by undercutting its own device sounds like a mistake. It is the most believable minute of the film, because a verdict is a judgement and a viewer trusts judgement more than a triumphant last shot.

So test in a place where the thing can break in front of people, and end with what you actually think. Your output is a final beat that answers the promise honestly: did it work, would you use it, what would you change.

Build video checklist

  • Promise sentence written, with the twist that makes it a video
  • Six to ten beats, each one a moment you can point a camera at
  • An empty slot in the beat list for the obstacle
  • Keep and compress list for technical detail
  • Every session: wide of the bench, hands, screen at source, time marker
  • Terminal font enlarged before recording
  • Failure log, each entry tagged changed the plan or delay
  • A public test where the build can still fail
  • A closing verdict in your own words
  • Chapters drafted: first at 00:00, at least three, none under 10 seconds
Copy it into your project notes. A pre-flight list, not a guarantee that the build will cooperate.

If it went wrong, it is one of these

SymptomCauseFix
Viewers leave during the technical stretchBoth audiences averaged in one laneCompress it into a visualizer or chapter, then check YouTube's key moments report for dips
The screen is unreadable on a phoneMonitor filmed with a cameraRecord at source and enlarge the font
It feels like an advertEvery failure was cutRestore the ones that changed the plan
The timeline feels like one long dayNo progress markersAdd time cards or say the day on camera
The ending is flatNo verdict, just a working objectClose on your judgement of the thing

Before committing to a long timeline, run a story check on the footage: it tells you whether the beats you planned survived the shoot.

What carries over to client work

This is the format closest to what a technical product launch needs: a real thing, demonstrated honestly, with the demo woven into a story rather than bolted onto it. Most launch films open with the brand promise and then demo a feature list as evidence. A build film shows the thing struggling into existence, and the promise arrives as a conclusion the viewer reached alone. It costs more to shoot, and I break down what moves that price in what a product launch video costs. For the contrast with a format where the day supplies the structure, see filming a startup vlog in Saigon.

The whole recipe on one line

Promise first, beats from the project, a lane for the tech, four kinds of coverage, only the failures that changed the plan, and a verdict at the end. If an old phone can carry an eleven-minute product story, your product can too, and that is the kind of film I make on the video side of the studio.

Sources and further reading

  • Video chapters

    YouTube HelpThe chapter rules quoted above: first timestamp at 00:00, at least three timestamps, minimum chapter length of 10 seconds.

  • Whisper

    OpenAI on GitHubThe general-purpose speech recognition model that turned the handset recordings into text prompts.

  • ScreenCaptureKit

    Apple Developer DocumentationCapturing screen content at source on macOS, which is how a terminal stays readable at phone size.

  • About secret scanning

    GitHub DocsScans a repository and its full Git history for hardcoded keys and tokens. Worth running before any build goes on camera with a live environment.

  • How to write a video script

    Vanpelt StudioThe promise line and beat list behind a structure that has to hold a technical explanation and a story at once.

Want a video like this made for your startup?

Video by the studio →Start a conversation →