Adaptive streaming is easy to use and harder to build. This project follows the entire path from an uploaded file to aligned video segments, reliable background jobs and a browser player that can change quality during playback.
— Case study 20
Reelcast
One upload, several video qualities, and a player that adapts to the connection

project overview
An on-demand video platform that turns an uploaded file into an adaptive HLS stream. Go and ffmpeg produce the renditions; an hls.js player selects the quality the connection can sustain.
shipped outcome
Upload, transcoding, browsing and playback work locally with PostgreSQL, Redis and MinIO. The worker's documented tests cover aligned segments, video bitrate within ±15% of target and retry after a worker is killed. The screenshots show a generated 75-second test clip, including Auto and manually selected 360p playback.
- Role
- Solo architecture and development
- Timeline
- 2026 — local streaming case study
- Year
- 2026
- Team
- Solo
The browser uploads directly to object storage through a presigned URL. NestJS records metadata and queues a BullMQ job. A TypeScript consumer holds the job lock while a Go process runs ffprobe and ffmpeg, generating an HLS ladder and thumbnail. Four-second keyframes align the renditions so hls.js can switch between them.
Upload, transcoding, browsing and playback work locally with PostgreSQL, Redis and MinIO. The worker's documented tests cover aligned segments, video bitrate within ±15% of target and retry after a worker is killed. The screenshots show a generated 75-second test clip, including Auto and manually selected 360p playback.
— Interface evidence
The product, not a placeholder
These are the verified interface captures from the project build. Scroll inside taller frames to inspect each complete page.




— Delivery process
From operating constraint to shipped system
The work is sequenced around risk. Domain rules and failure states come before interface polish; automation arrives before handoff.
Keep the pipeline focused
One product flow: upload a source, produce the renditions, play the result. The editor and general processing tools belong to the separate Plexus project.
Define the service boundary
The queue message carries videoId and sourceKey. Shared video and rendition records connect the TypeScript services to the Go worker.
Align the segments
Generate all renditions in one ffmpeg pass, force a keyframe every four seconds and handle source videos with no audio track.
Show progress without a reload
After the direct upload, a completion request queues the job. The browser polls its status until the player is ready.
Test the failure path
The worker test suite kills the Go child during an encode and checks that BullMQ retries the job to completion.
— System architecture
Clear boundaries, explicit responsibilities
Each layer has one job and a narrow contract. That keeps external services replaceable and product behavior testable.
source / one upload
1 file → 3 renditions
720p · 480p · 360p (never upscaled)
segments
4s · keyframe-aligned
player / guarantees
Next.js + hls.js
Browse, direct uploads, status polling and adaptive playback.
NestJS API
Stores metadata, issues upload URLs and queues transcoding jobs.
Redis + BullMQ
Retries, backoff and stalled-job recovery outside the HTTP request path.
TypeScript job-lock shim
Holds the BullMQ lock and starts the Go transcoder as a child process.
Go + ffmpeg
Probes the source, encodes the HLS ladder, uploads the output and updates video status.
Object storage + PostgreSQL
MinIO serves manifests, segments and thumbnails locally. Drizzle manages video and rendition records in PostgreSQL.
— What shipped
Product capabilities
Adaptive bitrate playback
hls.js selects the rendition according to bandwidth; the quality selector also supports manual playback checks.
Aligned quality levels
Forced keyframes keep four-second segment boundaries consistent across the ladder.
Non-blocking uploads
Presigned uploads send the file directly to storage without passing through the API.
Recoverable background jobs
BullMQ retries interrupted work instead of relying on a single long-running HTTP request.
— Engineering pressure
Challenges resolved
Segment boundaries affect playback
Natural keyframes produced uneven 4.8s and 3.2s segments. Forcing keyframes every four seconds made the rendition boundaries match.
Measure the video stream
Audio and MPEG-TS overhead made 360p appear 19% above its bitrate target. Probing only video packets separated encoder accuracy from packaging overhead.
Separate queue locks from media work
A small TypeScript consumer keeps BullMQ's delivery semantics while Go handles the CPU-intensive encoding work.
verified project destinations
next transmission
Need a system this deliberate?
Bring the operating problem. We will shape it into a clear product brief and a buildable next step.
Start a project