I wanted 60-second motion-graphics explainers that don't look AI-made, and I wanted them reproducible: change a script, get a new video, with the same quality every time. So I built the pipeline in code:

brief.json → per-scene TTS → word timings → React scenes (Remotion) → render 16:9 + 1:1 → loudness master → automated QA gate.

Here are the five traps that cost me the most time, and what fixed each one.

1. CRF on flat motion graphics gave me a 0.24 Mbps file

My first master used --crf=17. Flat colors compress extremely well, so the file came out at 0.24 Mbps. It looks fine locally, but platforms re-encode your upload, and starving them of bits hurts. I switched to a fixed target (--video-bitrate=8M), and the encoder still only used about 1.3 Mbps, because there's nothing left to encode. That's when I stopped trusting bitrate as a quality metric (see trap 2).

2. My PSNR check was measuring chroma subsampling, not quality

I added a fidelity check: render a lossless PNG still in Remotion, decode the same frame from the MP4, compute PSNR. It plateaued at 36.7 dB no matter what I did (CRF 12, CRF 8, 8 Mbps with the slow preset). If a metric doesn't move when you turn the knob, it's measuring something else. Here that was 4:2:0 chroma subsampling on thin colored lines, which every platform applies anyway. Luma-only PSNR on the same frame gave 48 dB. The gate now checks luma PSNR ≥ 40 dB.

def luma(p): a = np.asarray(Image.open(p).convert("RGB"), dtype=float) return 0.2126*a[...,0] + 0.7152*a[...,1] + 0.0722*a[...,2] 

3. 16% of my "60-second" video was silence

Generating TTS sentence by sentence and padding between them felt natural, until I measured it: 9 of 56 seconds were gaps of 0.3 s or more. Retention research says one deliberate pause before the key reveal, not twenty. So now:

  • internal pauses are clamped to 0.18 s;
  • there are 0.12 s between scenes;
  • exactly one pause of ≤ 0.6 s, flagged in the brief ("keep_pause": true), stays in;
  • the QA gate fails the video if there's more than one gap of 0.3 s or more.

Removing silence speeds the pace up, so I lowered the TTS speed slightly to land back at ~150 wpm.

4. Animations keyed to frames drift; key them to words

Every scene gets its own TTS clip, so scene starts are exact. Inside a scene, I look up the frame where a word is spoken:

export const at = (s: Scene, token: string) => { const w = s.words.find((x) => x.text.toLowerCase().includes(token.toLowerCase())) ?? s.words[0]; return Math.round((w.start - s.start) * 30); }; // <Counter to={59} at={at(s, 'fifty')} suffix="%" /> 

When the narrator says "fifty-nine percent", the counter starts counting. Change the script and everything re-syncs.

One gotcha: I first triggered a counter on the word itself, and at the end of the scene it showed 41% instead of 66%, because the tween had only just started. Trigger reveals one word earlier.

5. A contact sheet of stills catches layout bugs in one minute

Before rendering (minutes), I render one still per scene near its end and tile them into a single contact sheet. In one pass that caught:

  • text wrapping;
  • a stamp covering the price;
  • an email cut mid-sentence;
  • labels overflowing their nodes;
  • a 27 px font in the square format.

These are 9 bugs in total that a full render would have hidden until I watched every second.

The QA gate (21 automated checks)

  • pace (145 wpm ±10%)
  • ≤ 7 words on screen
  • no linear easing
  • only theme easing tokens
  • body text ≥ 32 px at every aspect ratio
  • ≤ 2 font families and theme colors only
  • a sourced number in the brief
  • silence budget
  • captions ≤ 42 chars per line, with no 1-word pages
  • SRT exported
  • both ratios rendered
  • H.264 High, AAC 48 kHz, fast start
  • luma PSNR ≥ 40 dB
  • loudness -14 LUFS ±1 with true peak ≤ -1 dBTP
  • no black frames
  • one CTA

Checks that can't be automated (does the metaphor land without sound?) stay on a human checklist.

Stack

  • Remotion for the React scenes. It's free for individuals and companies of up to 3 people; above that you need a company license.
  • Kokoro (Apache-2.0) for the local TTS voice.
  • Remotion's bundled ffmpeg for the two-pass loudnorm.
  • A Python script for the QA gate.

Everything renders on a laptop CPU in about 2 minutes per format.

If you want the whole thing as a starting point, I packaged it as the Remotion Explainer Kit: source, a complete demo project, the TTS pipeline and the QA gate → https://payhip.com/b/l8bM3. If you'd rather have someone make the video, we also do that: https://payhip.com/b/zFAxc

Examples of what it renders: https://drive.google.com/drive/folders/1w9K4oh6kOtWaZ6S0YHXWUV4kSQQJjT31