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.
— Case study 19
Video Converter
Heavy, bursty video work split off behind a queue, so one upload never freezes the app

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



— 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.
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.
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.
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.
Containerise and orchestrate
Every service ships as a Docker image with health checks; Kubernetes manifests then define replicas, resources and restart behaviour.
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.
gateway / public edge
accept → return
an upload never blocks a request
heavy path
async only · off the request
services / decoupled
Next.js frontend
Upload UI with job-status polling and download of the finished audio — a deliberately thin surface over the pipeline.
API Gateway (NestJS)
The single public entry point: validates requests, checks auth, publishes jobs, and never blocks on conversion.
Auth service
Owns users and tokens so no other service touches credentials.
RabbitMQ
Durable queues decouple request from processing and provide retries and backpressure for free.
Converter + Notification services
Independently scalable consumers: conversion runs off queue depth, notifications fire on completion events.
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
Non-blocking uploads
The request returns as soon as the file is safely stored and the job is queued.
Independent scaling
Add converter replicas without touching the API tier — the whole reason for the split.
Automatic retries
A worker crash re-queues the message instead of dropping the job.
Completion notifications
A dedicated service watches for finished jobs and tells the user when the file is ready.
— Engineering pressure
Challenges resolved
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.
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.
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 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