Library/Make Video Courses with Code·Session 1 of 5

Why code beats recording (for course video)

20 minSaves $24/mo
Transcript

Most course video gets recorded, and re-recorded, one flub at a time, then patched together by hand. This session shows a different way: write your video as data, generate the narration, and render it with code, so every fix becomes a text edit.

Recording repeats a performance every time something changes: script, record, fix the flub, edit the cut, export. Rendering from code repeats a computer job instead: script, structured data, one render command. The upfront cost buys a much cheaper fix, forever after.

Open a terminal and run three real commands: scaffold a blank Remotion project, move into the new folder, and start the dev server. Remotion Studio opens in your browser, showing a live, empty composition. That empty project is today's whole proof.

Every lesson you make follows the same four stops: a manifest holding your script, a render turning that data into video, a compressed web cut, and a hosted file your course platform can play. Learn this path once, then reuse it forever.

Picture fixing one typo in your narration. On the recording side, you hunt for the take, re-record the line, and re-cut the export. On the rendering side, you edit one string in a file and re-render, unattended, while you do something else.

This is not for every video. If a person's face or real hands on camera is the point, keep your camera. If you are making one single video, recording is still faster. Code pays off once you have a real library.

Session two has you write this file yourself: a manifest holding your scenes, your narration, and the small details each scene needs. It is not a video yet. It becomes one exactly once, the same way, every single time you render it.

You are done when Remotion Studio runs from one command, you have decided whether your content is code-shaped or camera-shaped, and you have named one real video where a fix should have been a text edit instead of a re-shoot.

That is session one. You have a working project and an honest answer about whether your video is code-shaped. Session two turns that answer into a real schema: the exact JSON shape every future lesson video of yours will follow, starting today.

Most course video gets made the same way: write a script, sit down and record it, flub a line, record it again, cut the good takes together in a timeline editor, export, and hope nobody asks for a fix next month. Fix one typo in the narration and you are back in the editor, hunting for the exact frame to patch. Rebrand your business and you are re-recording every video that shows your old logo. That loop does not get cheaper as you make more videos. It gets more expensive, because every video is a one-off performance you have to protect forever.

This course teaches a different loop: write the video as data, generate the narration, render it with code, and treat every fix as a text edit instead of a re-shoot. This is session 1 of the Make Video Courses with Code course, the one where you decide whether that trade is worth it for you, and prove it to yourself in about twenty minutes.

What you will use

  • Node.js 18 or newer and a terminal
  • A text editor
  • Remotion, a free, open source library that builds real video out of React components and renders it to an actual video file (docs at remotion.dev/docs)
  • Nothing else yet. Later sessions add a text-to-speech API and ffmpeg; this session only needs the terminal and five minutes

Step 1: Name the trade you are actually making

Recording-based production is a loop you repeat forever: script, record, re-record the flubbed line, edit a timeline, export, and repeat the whole loop the next time something needs to change. The cost of a fix is the cost of a new shoot.

Code-based production moves the "performance" out of a take and into data. You write a script, generate narration from it, and a program renders the video deterministically from that data every time. The cost of a fix becomes the cost of editing a line of text and re-running one command. You pay for this trade upfront: someone has to build the rendering pipeline once. This course is that upfront cost, paid in five short sessions instead of a slow, expensive rebuild the first time you need to fix ten videos at once.

Step 2: See what "video from code" actually means

A composition in Remotion is a normal React component. Instead of rendering to a browser tab, it renders to a sequence of frames, and those frames get encoded into a video file. The component you write is reusable: the same "title card" or "terminal window" template can draw a hundred different videos, each one fed different data (a title, a list of steps, a block of narration text).

That data-driven shape is the whole idea of this course. Session 2 has you write that data format yourself, as a JSON file per video. For now, the only thing to understand is: what you see live in Remotion's preview studio is pixel-for-pixel what gets exported, because it is the same React rendering, just captured to frames instead of displayed on a screen.

Step 3: Do the smallest possible proof, right now

Open a terminal and scaffold a real, blank Remotion project. This is the exact command from Remotion's own documentation (remotion.dev/docs):

npx create-video@latest --yes --blank my-course-videos
cd my-course-videos
npm run dev

The first line scaffolds a new project with a blank starter template and no interactive prompts. The second moves you into it. The third starts Remotion Studio, which opens in your browser and shows you a live, editable preview of your (currently empty) composition.

Do not close that terminal. You now have a real, renderable video project on your machine, with zero content in it. That is the correct starting point: everything from here is about filling it, never about switching tools.

Step 4: See the economics that make this worth it

The payoff of a code pipeline does not show up on video one. It shows up on video ten, and especially on the day something changes across all of them:

  • A typo in the narration. Recording: re-record the sentence, find the cut point, re-export. Code: edit one string in a JSON file, regenerate one narration file, re-render (about three minutes, unattended).
  • A rebrand. Recording: re-shoot or re-edit every video that shows your old colors or logo. Code: change a handful of color values in one style file, and re-render every affected video as a batch job you can start and walk away from.
  • A second version for a second audience. Recording: a second full shoot. Code: the same manifest, rendered again with a different visual skin, covered in session 5 of this course.

Caution. This is not the right tool for talking-head video, a real product in someone's hands, real b-roll, or anything where a human face and voice on camera is the point. It is built for diagram-and-narration explainer video: software walkthroughs, internal training, and structured course content like this lesson itself. If your video needs a person on camera, keep your camera; use this course for everything else you are currently recording a screen for.

Step 5: See where this course is going

Five sessions, one pipeline, built one piece at a time:

  1. This session. Decide if code-built video fits what you make, and get a blank project running.
  2. Write the scene schema and manifest. Design the JSON shape that describes one of your videos: title, steps, narration, in order.
  3. Narration, covers, and accuracy. Generate spoken narration from text with a TTS API, make a cover image, and lock in the rule that nothing on screen gets invented.
  4. Render, encode, and host. Turn a manifest into an actual video file, compress it for the web, and put it somewhere your course platform can serve it from.
  5. Brand variants and scale. Reuse one script across brands, build a course trailer, and re-render everything in a batch the day your brand changes.

Do this now

  • Run the three commands in Step 3 and confirm Remotion Studio opens in your browser.
  • Open the folder create-video just made in your editor and look at what is already there, so session 2's schema has a place to live.
  • Write down one video you currently record by hand, and the one thing about it (a typo, a stat, a logo) that has changed since you recorded it.

You are done when...

You have a blank Remotion project running in Studio, in your browser, from a single terminal command. You can say, in one sentence, what a "manifest" is going to be for you: the text and structure of one video, kept separate from the code that draws it. And you have one honest answer for whether your course video is diagram-and-narration shaped, or camera-and-performance shaped, because that answer decides whether the rest of this course pays off for you.

Sources: Remotion documentation at remotion.dev/docs.


Template included: Members get the "does code beat recording for me" decision checklist and a starter folder layout for a code-built lesson video project. Find it in your member dashboard under Templates.

Want it done for you?

Short on time? Agentic Quarks will implement this end to end, wired into your stack, and hand you the keys.

Implementation engagements from $2,500
The course this session belongs to

What you will build in Make Video Courses with Code

Write the scenes, render them, host them, and ship a cut for every brand

5 sessions, 153 minutes, 1 free.

  1. 01Why code beats recording (for course video)Free20 minYou are here
  2. 02Write the scene schema and manifestMember32 min
  3. 03Narration, covers, and the no-invented-facts ruleMember35 min
  4. 04Render, encode, and host your lesson videosMember38 min
  5. 05Brand variants, trailers, and scaling upMember28 min
Browse all courses

One payment, no subscription, and a 14-day money back you trigger yourself from your account page. This course on its own is $99.

Members share their results from this session in the community. See what is included.