blessed_moon@studio
studio: Blessed Moon Studio
founder: Benito Pedro Xavier · Solo studio
discipline: Strategy · Design · Engineering
stack: Next.js · Tailwind · WebGL
scene: ASCII moon · 5 keyframes
type: Space Grotesk / JetBrains Mono
accent: #ff6a1f
sound: muted
status: ready
B / S / MCASE_20 / 26

— Case study 20

Reelcast

One upload, several video qualities, and a player that adapts to the connection

All work
reelcast.capture● verified
Reelcast playing a generated test clip at 720p, with Auto quality selected and the 720p, 480p and 360p renditions listed below

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 problem01

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.

The approach02

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.

The result03

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.

The Reelcast upload form with title, description and a video file picker01 / 04
The Reelcast upload form with title, description and a video file picker
A submitted video's status moving through uploading, queued, processing and ready without a page reload02 / 04
A submitted video's status moving through uploading, queued, processing and ready without a page reload
The Reelcast browse page listing a ready video with its generated thumbnail03 / 04
The Reelcast browse page listing a ready video with its generated thumbnail
The same generated clip playing with the quality selector set manually to 360p04 / 04
The same generated clip playing with the quality selector set manually to 360p

— 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.

01

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.

02

Define the service boundary

The queue message carries videoId and sourceKey. Shared video and rendition records connect the TypeScript services to the Go worker.

03

Align the segments

Generate all renditions in one ffmpeg pass, force a keyframe every four seconds and handle source videos with no audio track.

04

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.

05

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.

Next.jsNestJSGoffmpeghls.jsBullMQ / RedisPostgreSQLS3 / MinIO
reelcast.syssystem schematic

source / one upload

1 file → 3 renditions

720p · 480p · 360p (never upscaled)

segments

4s · keyframe-aligned

●align or every switch stalls

player / guarantees

presigned put · api skips bytes[x]
bullmq retry · no lost jobs[x]
hls.js abr · drops on bandwidth[x]
bitrate ±15% · video stream[x]
live · dash · drm[ ]
upload → queue → go/ffmpeg → hls → play
Client

Next.js + hls.js

Browse, direct uploads, status polling and adaptive playback.

API

NestJS API

Stores metadata, issues upload URLs and queues transcoding jobs.

Queue

Redis + BullMQ

Retries, backoff and stalled-job recovery outside the HTTP request path.

Queue consumer

TypeScript job-lock shim

Holds the BullMQ lock and starts the Go transcoder as a child process.

Transcoder

Go + ffmpeg

Probes the source, encodes the HLS ladder, uploads the output and updates video status.

Storage + DB

Object storage + PostgreSQL

MinIO serves manifests, segments and thumbnails locally. Drizzle manages video and rendition records in PostgreSQL.

— What shipped

Product capabilities

01

Adaptive bitrate playback

hls.js selects the rendition according to bandwidth; the quality selector also supports manual playback checks.

02

Aligned quality levels

Forced keyframes keep four-second segment boundaries consistent across the ladder.

03

Non-blocking uploads

Presigned uploads send the file directly to storage without passing through the API.

04

Recoverable background jobs

BullMQ retries interrupted work instead of relying on a single long-running HTTP request.

— Engineering pressure

Challenges resolved

01

Segment boundaries affect playback

Natural keyframes produced uneven 4.8s and 3.2s segments. Forcing keyframes every four seconds made the rendition boundaries match.

02

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.

03

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 case studyApuração 2026

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