← ALL WORK

PRODUCT ENGINEERING

Cutline.

AI-assisted video production engine

MY ROLEEnd-to-end product and system engineering
STATUSWorking product
STACKReact · Node.js · FFmpeg · Whisper · Qwen3-TTS · PostgreSQL
FIELD NOTE / 01

See the system in motion.

Product video · 00:32

SBV / CUTLINEPRODUCT VIDEO
WHAT THIS SHOWS

An excerpt from a promotional video made with Cutline, showing the editor and product workflow.

SOURCE / LIMIT

Actual product footage from the local Cutline dogfooding project. This excerpt is silent.

Open video ↗
FROM THE SOURCE

A closer look at Cutline.

02 ORIGINAL VISUALS

01 / The editing surfaceCutline dogfooding project · product screenshot

The Cutline editor brings the script, preview and timeline into one production workspace. Captured during the local promotional video project.

02 / From topic to production briefCutline dogfooding project · product screenshot

The creation dialog exposes the inputs that shape AI-assisted scripting and video generation.

CUTLINE / 01 OF 02
Cutline editor showing a video preview, script steps, editing controls, and a multitrack timeline.

The editing surface

The Cutline editor brings the script, preview and timeline into one production workspace. Captured during the local promotional video project.

ENGINEERING DOSSIER / CUTLINE

The decisions
behind the system.

A video product crosses several compute boundaries: interactive editing, language generation, GPU speech, and deterministic media export.

OWNERSHIP

End-to-end product and system engineering, from React studio and Node API to native speech services, queueing, and final render.

VERIFIED PRODUCT CHECKPOINTThe app produced a 114.9-second promotional video in horizontal and vertical formats through its own API and exporter.

That is a local dogfooding result. Production export reliability was still being investigated in the October 2026 test notes.

ARCHITECTURE / DECISION RECORDS
01

Keep GPU inference on the host

CONTEXT
Docker Desktop on macOS runs a Linux VM without direct access to Apple Metal acceleration.
CHOICE
Run the web app and export services in containers; serve Whisper, Qwen3-TTS, and avatar work from a native GPU process.
CONSEQUENCE
The interface stays deployable while speech work uses the available hardware. The cross-process boundary needs explicit authentication and failure handling.
02

Treat rendering as a resource-managed job

CONTEXT
Speech, deck generation, and FFmpeg export have different costs and cannot safely compete in one request cycle.
CHOICE
A SQLite-backed queue separates work and limits GPU and CPU concurrency; PostgreSQL holds users and project data.
CONSEQUENCE
The editor can remain responsive while exports progress, and resource pressure becomes an operational concern that can be measured.
03

Test the product with its own output

CONTEXT
An architecture diagram cannot reveal typography, voice, transition, or vertical-format failures in a rendered video.
CHOICE
Create the Cutline promo through the product API, then document export friction alongside the successful output.
CONSEQUENCE
The result proves an end-to-end path and gives concrete defects to fix, including media composition and export reliability.
EVIDENCE & LIMITS

The embedded excerpt is silent. The longer local promotional output and internal operational records are not distributed here.

  • SystemCutline architecture document, including process boundaries, open-slide rendering, and tested export paths.
  • ProductThe embedded 32-second excerpt shows the actual editor and product workflow.
  • DogfoodingCutline promo README records API steps and completed 16:9 and 9:16 outputs; friction log records remaining issues.
SYSTEM MODELSELECT A COMPONENT TO EXPLORE →
SELECTED COMPONENTReact studio

Script, timeline, media editing, and export controls.

01 / THE PROBLEM

One video, four kinds of compute.

Turning a script or a recording into an edited, narrated video mixes very different work: interactive editing, language generation, GPU speech and deterministic rendering. Each one needs the right place to run.

02 / THE APPROACH

A studio in the browser, GPU work on the host.

A React studio talks to a Node/Express API with a SQLite-backed job queue. A native GPU service handles transcription and voice, a cloud model helps with the script, open-slide renders slides written in the browser, and FFmpeg assembles the final export.

03 / THE DECISION

Put inference where the GPU actually is.

On macOS, Docker can't reach the Apple GPU. So GPU inference runs natively on the host, while the web app and export services stay in containers. The price is a boundary between processes that needs its own authentication and failure handling.

04 / THE OUTCOME

It made its own promo video, and logged what broke.

I used Cutline to make its own 114.9-second promotional video, exported in horizontal and vertical formats. The same exercise produced a friction log, including export reliability issues in production that were still open.

SOURCES

Cutline's architecture document and the records of its promotional video. Code and internal links stay private. This page summarizes what those documents show.

NEXT CASE STUDYAgent Private Credit ↗