A platform that learned to grow sideways—only when the workload earned it.
My first horizontally scaled platform taught me that distribution is not a starting point or a badge. I designed the seams that let a single-server deployment become load-balanced application and analytics tiers, separate Redis services, workers, object storage, search, and realtime infrastructure without turning each move into a risky rewrite.
Role
Technical Director
Context
Multi-tenant business platform
Disclosure
Client-anonymous
The problem
The problem
The original single-machine model was the right place to start, until it was not. A request could land on either application server, so it could not depend on a temporary upload or other state living locally. High-volume analytics could not compete with the interactive product. And, once the system crossed a million jobs a day, one Redis instance carrying both cache and queue pressure became a real operational constraint. The challenge was to add the right separation without treating every deployment like a hyperscale problem.
1M+jobs processed each day before queue isolation became necessary
2 + 2load-balanced application and analytics web apps
2dedicated worker servers
Remotestate designed to survive any request landing anywhere
What I built
The system, not just the screen.
A request path that can land anywhere
Moved the state that cannot be machine-specific out of the web box, including temporary uploads that have to remain available when a subsequent request lands on a different app server. Object storage and remote services make the web tier replaceable instead of quietly stateful—a particularly important constraint for Livewire-style uploads and follow-up requests.
Workloads separated by the pressure they create
Built an interactive application tier behind a load balancer, a separate load-balanced analytics tier for web traffic, dedicated worker servers, distinct Redis services for cache and queues, managed MySQL, object storage, search, and realtime infrastructure. The objective is not to maximize the server count; it is to keep one workload from taking another one down with it.
An intentionally modest default
I still begin a normal client deployment on one machine with the services it needs. The difference is that I now build it as though those services may be separated later: remote-friendly state, clear workload boundaries, and deployment paths that let us add capacity with minimal downtime once evidence—not anxiety—says it is time.
System sketch
How the system works.
A simplified view of the system boundary and the work it moves through.
Load-balanced web apps
Remote state + uploads
Cache and queue Redis
Dedicated workers
Analytics, search + realtime
Key decisions
Key decisions
Start with one box when it is appropriate, but never make the application depend on that box being special.
Keep upload state, shared cache, queues, and durable files remote so a load balancer can safely choose any healthy app server.
Separate cache from queues once the evidence showed more than one million daily jobs could exhaust the shared Redis capacity.
Give high-volume analytics its own web path so tracking traffic cannot crowd out the people using the product.
What it enables
What it enables
The result is a platform with practical operating levers: application capacity, analytics capacity, workers, cache, queues, database, storage, search, and realtime services can each be adjusted without forcing a redesign of the rest. More importantly, it shaped how I build smaller systems too—simple at first, but ready to separate cleanly when the work proves it is necessary.