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_19 / 26

— Case study 19

Video Converter

Heavy, bursty video work split off behind a queue, so one upload never freezes the app

All work
video_converter.capture● verified
Video Converter dashboard — an upload dropzone titled 'Video to MP3 Converter', with 'Upload a video file to convert it to MP3 audio'

project overview

A microservices pipeline that turns a video upload into an MP3 without ever blocking the request: a gateway accepts the file and returns immediately, a message goes onto RabbitMQ, and a dedicated converter does the transcoding whenever it has capacity — so conversion capacity scales on its own and a crashed worker means a retried message, not a lost file.

shipped outcome

Uploads return instantly, conversion capacity scales independently of the web tier, and a worker crash re-queues the message instead of dropping the file. The whole stack comes up with one Docker Compose command, every service ships as an image with health checks and Kubernetes manifests, and an end-to-end test drives a real upload through a real queue and both databases rather than mocking them.

Role
Solo architecture and development
Timeline
2024 — 3-month build, open source
Year
2024
Team
Solo
The problem01

Converting video is slow and CPU-hungry. Done inside the web request, one upload blocks the server, the user watches a spinner, and a browser timeout loses the whole job. Scaling that naive design means scaling the entire application just to buy more conversion capacity, even though the API itself is cheap and constant.

The approach02

The system is split into small services that talk through a message queue instead of calling each other directly. The gateway is the only public entry point: it validates the request, stores the file, publishes a job, and returns. A converter service consumes those jobs whenever it has capacity, runs the transcode, and publishes a completion message that a notification service reacts to. None of them call each other synchronously on the heavy path, so 'work requested' is fully decoupled from 'work performed' — the one thing that makes the converter scalable on its own. Large files go to MongoDB GridFS, which chunks them across documents so an upload or result is streamed rather than held whole in memory; the relational data — users, jobs, statuses — stays in PostgreSQL.

The result03

Uploads return instantly, conversion capacity scales independently of the web tier, and a worker crash re-queues the message instead of dropping the file. The whole stack comes up with one Docker Compose command, every service ships as an image with health checks and Kubernetes manifests, and an end-to-end test drives a real upload through a real queue and both databases rather than mocking them.

— 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 sign-in page — the gateway validates authentication before any upload is accepted01 / 03
The sign-in page — the gateway validates authentication before any upload is accepted
A video file selected and ready, with the 'Convert to MP3' action02 / 03
A video file selected and ready, with the 'Convert to MP3' action
A real upload in progress — the file is queued and shows 'Converting…' while a worker transcodes it off the request path03 / 03
A real upload in progress — the file is queued and shows 'Converting…' while a worker transcodes it off the request path

— 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

Find the bottleneck first

A naive single-service version was profiled before anything was split. The conversion step dominated everything, which is what justified microservices — they were a measured conclusion, not a starting assumption.

02

Design the message contracts

The payloads on the wire were written before any service was extracted. In a queue-based system the message contract is the real API, so it was designed deliberately rather than falling out of the code.

03

Extract one service at a time

Auth first, then conversion, then notifications. Each extraction kept the system running, so there was never a big-bang rewrite to debug.

04

Containerise and orchestrate

Every service ships as a Docker image with health checks; Kubernetes manifests then define replicas, resources and restart behaviour.

05

Prove it end to end

An end-to-end test uploads a real file and asserts the MP3 comes back, exercising the queue and both databases rather than stubs.

— System architecture

Clear boundaries, explicit responsibilities

Each layer has one job and a narrow contract. That keeps external services replaceable and product behavior testable.

NestJSNext.jsRabbitMQPostgreSQLMongoDB GridFSDockerKubernetesTypeScript
video_converter.syssystem schematic

gateway / public edge

accept → return

an upload never blocks a request

heavy path

async only · off the request

●crash = retried message

services / decoupled

gateway · only public entry[x]
rabbitmq · durable queue[x]
converter · scales alone[x]
gridfs · large files[x]
sync calls on heavy path[ ]
upload → queue → converter → notify
Client

Next.js frontend

Upload UI with job-status polling and download of the finished audio — a deliberately thin surface over the pipeline.

Edge

API Gateway (NestJS)

The single public entry point: validates requests, checks auth, publishes jobs, and never blocks on conversion.

Identity

Auth service

Owns users and tokens so no other service touches credentials.

Async

RabbitMQ

Durable queues decouple request from processing and provide retries and backpressure for free.

Workers

Converter + Notification services

Independently scalable consumers: conversion runs off queue depth, notifications fire on completion events.

Storage

PostgreSQL + MongoDB GridFS

Relational data for users and jobs; chunked binary storage for the media itself, streamed rather than held in memory.

— What shipped

Product capabilities

01

Non-blocking uploads

The request returns as soon as the file is safely stored and the job is queued.

02

Independent scaling

Add converter replicas without touching the API tier — the whole reason for the split.

03

Automatic retries

A worker crash re-queues the message instead of dropping the job.

04

Completion notifications

A dedicated service watches for finished jobs and tells the user when the file is ready.

— Engineering pressure

Challenges resolved

01

At-least-once delivery means idempotency

Queues can deliver a job twice, so consumers check job state before working — reprocessing a message is harmless by construction, not by luck.

02

Six moving parts, one command

A distributed system is hostile to onboarding, so Docker Compose brings the entire stack up with one command and seeded data.

03

Tracing a failure across services

A job id propagates through every message, so a single upload can be followed across the gateway, converter and notification service.

verified project destinations

next case studyLunares

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