Where the 8 years went.

I started ReelM in February 2026, while I was still running engineering at Bupple. It came out of hitting the same wall over and over in the media work: agents plan an edit well and cannot execute one, because everything we hand them is a text box that returns a file. I wanted to know whether the agent could work inside the editor instead, on the same timeline as the person watching, so I built the thing that would answer it.

Founding it means I own all of it. What gets built and what does not, the desktop app, the API, billing and subscriptions, the release process, the documentation, and the support message at eleven at night. It is the first time I have carried something from an empty repository through to people paying for it, and the part that genuinely surprised me is how much of the job turns out to be deciding what to leave out.

The engineering judgment shows up in unglamorous places. Installed software updates on its owner's schedule rather than mine, so anything I might want to change later cannot be baked into the build. A project somebody saves has to still open in a year, so the file format shipped with versioned migrations in the first release rather than the fifth. Those are calls I would make on someone else's platform too. The difference is that here there is nobody above me to escalate a bad one to.

It is what I am working on now. The short version, if you are hiring: I have spent this year making every call myself and watching closely which ones held.

I came in to build the AI and media platform and ended up owning the engineering side of it. The product turns raw media into something publishable, which sounds tidy until you count the moving parts: ingestion, transcription, inference, rendering, delivery, and an interface that has to stay calm while all of that is happening on someone else's machine.

The services were Node with NestJS and Python with FastAPI, and at peak they answered around half a million requests a minute. Behind them, BullMQ on Redis ran the parallel workers for rendering, transcription, inference and analysis, roughly fifteen hundred jobs a minute, with retries, backoff and idempotency designed in from the start instead of bolted on after the first bad night.

Ingestion, processing and delivery stayed apart because the queues kept them apart, not because everyone agreed to be careful. A slow render could not back up an upload, and an inference worker falling over could not take the API with it. Fan out and backpressure turned into numbers to tune rather than incidents to survive. Progress, state sync and presence went out over WebSockets and Pub/Sub with reconnect safety and message ordering handled deliberately, because when a render takes minutes the progress stream is the product.

Rendering ran on GPU through CUDA enabled FFmpeg, tuned to stay predictable under heavy parallel load. On the model side I built agent workflows and RAG pipelines for chat driven editing, lifted retrieval quality with embedding based ranking, trained a model that spots emerging social trends from contextual and behavioural signals, and deployed custom LLM variants on our own multimodal data. A research to production loop kept pulling live data into the training set so none of it went stale.

Then the half nobody demos. Structured logging, metrics, alerts, queue monitoring, safe rollouts, failure isolation. I also built the Remotion based video editor, timeline overlays and auto captioning included, which is where I learned exactly how much patience people have for a timeline that stutters. None.

The core was a Laravel monolith that had quietly stopped scaling at the exact hours that matter, which for a taxi platform is Thursday night. I re-architected pricing, dispatch and payments into NestJS services and moved them across while the old system kept taking rides. Core flows came out about twenty percent faster and peak hours stopped being a standing item in standup.

Kafka carried ride, payment and support events between the new services, so a slow payments consumer could no longer drag dispatch down with it. BullMQ and Redis took the background load: event consumers, notifications, support workflows, scheduled jobs. Traffic spikes stopped arriving at the user as latency.

Real time is the part riders actually feel. State updates, driver and rider status, progress streaming, all over WebSockets and Pub/Sub, with reconnect behaviour designed rather than assumed, because phones lose signal in tunnels and the app has to come back correct rather than just come back.

I also shipped an encrypted, AI assisted help desk that handled more than ten thousand inquiries a month and cut response time by about a third, worked with the frontend team on API contracts until page loads dropped fifteen percent, and spent a productive week with a profiler on the worst endpoints and the queries underneath them, which took another twenty seven percent off peak response times. Auditing and refactoring the risky paths closed around forty percent of the open security issues, with no incidents while I was there.

The platform ran on a legacy Symfony codebase. I led the migration of the core logistics flows and the ISP integrations to Node with Fastify, and deliberately left the employee dashboard where it was. Rewriting a working internal tool for the sake of consistency is how migrations quietly turn into two year projects.

The shipping gateway I built handled over fifty thousand shipments a month and cut shipping errors by about a third. The high traffic endpoints got caching, indexing and query tuning, which took roughly forty percent off response times where it was actually being felt.

RabbitMQ carried the shipment lifecycle events and the coordination with the ISPs, so load spikes spread out instead of landing all at once. I also built the gateway API for mobile device registration, which has since processed more than seventy three thousand registrations, and rebuilt authentication and the KYC flow around something over a hundred thousand accounts.

I rebuilt a large accounting system on Laravel and moved more than five million records into PostgreSQL. Financial data does not forgive an approximate migration, so it went over in verified batches with reconciliation at every step. Query times came down by about half once it landed.

The more interesting half was on the production floor. I wrote Python connectors that read the machines directly and fed their signals into the platform, which lifted efficiency around twenty percent and output around thirty. Watching a number move on a dashboard because a machine on the other side of a wall did something is still one of the better feelings in this job.

The heavy work, reporting, reconciliation and data sync, went onto BullMQ and Redis so the people who needed the numbers stopped waiting on a page to load. Between that and the stability work, downtime dropped about forty percent.