The Three Stages Every Growing Backend Goes Through (Netflix Included)
Monolith, then microservices, then a gateway to hide the seams — the same three-stage shape shows up whenever a system outgrows its original architecture.
On this page
“When should we break up the monolith” is a question every growing engineering team eventually asks, and the honest answer is almost never “now, preemptively” — it’s “when a specific, felt pain shows up.” The useful pattern to notice isn’t a rule about when to split; it’s the shape the split actually takes once it happens. Three stages, each solving a distinct problem the previous stage didn’t anticipate needing solved.
Stage 1: the monolith is the correct starting architecture
A single codebase, a single API layer, a single database — client, API, database, done. This isn’t a placeholder architecture waiting to be replaced; for a small team building toward product-market fit, it’s the correct choice. No network calls between your own components. No distributed-systems failure modes (partial failures, eventual consistency, service discovery) to design around before you’ve even validated the product needs to exist. One deploy pipeline, one thing to monitor, one mental model for the whole system.
The mistake isn’t starting with a monolith — it’s mistaking “monolith” for “wrong” independent of actual symptoms. The trigger for stage two is never “we read that microservices are best practice.” It’s a specific, felt problem.
Stage 2: extract what’s actually causing pain, leave the rest
The problem that actually forces change is rarely raw performance — it’s engineering velocity. As a monolith’s surface area grows, more engineers work in the same codebase simultaneously, deploys grow larger and riskier, and a bug in one feature area can take down features that have nothing to do with it, because everything shares the same process and the same deployment unit.
The typical second stage isn’t “microservices everything at once” — it’s targeted extraction. Specific, high-churn features get pulled into their own independently deployable services, while broader coordination and routing logic stays centralized for now. This captures a real, immediate benefit (the extracted features can now deploy independently, and a bug in one doesn’t take down the others) without yet solving a harder problem the team may not be ready for: fully decoupling every client from a growing, shifting set of backend services.
Not every system needs to reach stage three. A team that’s extracted its highest-churn, highest-risk features into independent services has already captured most of the velocity and blast-radius benefits microservices offer. Pushing further only pays off once client-to-service coupling itself becomes the bottleneck — which is a distinct, later problem.
Stage 3: a gateway hides the backend’s shape from every client
Once a backend has genuinely split into many independent services, a new problem surfaces that extraction alone doesn’t solve: clients now need to know about, and directly call, a growing and shifting set of individual services. A mobile app or web frontend built to call service A, B, and C directly has to change every time A, B, or C is added, removed, merged, or restructured — the backend’s internal architecture leaks directly into every client’s code.
An API gateway resolves this by inserting one stable entry point between clients and the backend’s internal topology:
Before (stage 2): After (stage 3):
Client ──▶ Service A Client ──▶ Gateway ──▶ Service A
Client ──▶ Service B ──▶ Service B
Client ──▶ Service C ──▶ Service C
Client ──▶ Service D ──▶ Service D
(client must know every (client only knows the
service directly; any gateway; backend can
backend change ripples restructure freely
to every client) behind it)
The gateway can route requests to whichever service currently owns a given responsibility, ordering and coordination logic can live at the gateway layer instead of being duplicated in every client, and the backend is now free to evolve its internal service boundaries without every client needing a corresponding update.
Why this shape recurs across companies
Do
Treat each stage as the response to a specific, already-felt problem: monolith while velocity is fine, extraction once specific features are causing deploy risk or team contention, a gateway once client-to-backend coupling itself becomes the bottleneck.
Don't
Jump to stage three architecture (a full gateway, fully decomposed services) before stage one or two problems have actually appeared. That’s paying real complexity cost — operational overhead, distributed debugging, network latency between your own components — against a problem you don’t have yet.
The three stages aren’t a checklist any growing system must complete — they’re a recognizable shape that emerges when growth actually forces architectural evolution, because the three problems (iteration speed vs. deploy risk, deploy risk vs. client coupling, client coupling vs. backend flexibility) tend to surface in that order as a system’s team, feature surface, and client diversity all grow together.
Takeaway
The useful lesson from watching a backend evolve through these stages isn’t “here’s the target architecture to build toward” — it’s recognizing which of the three problems you’re actually facing right now. A team still iterating fast with a small surface area doesn’t need a gateway; it needs to keep shipping. A team where one team’s bug regularly breaks an unrelated team’s feature has a real stage-two problem worth solving. A team where every client update requires touching a dozen call sites across a sprawling service list has a real stage-three problem. The architecture that fits is the one solving the problem you actually have, not the one that looks most sophisticated on a diagram.
Frequently asked questions
Why does a monolith make sense as a starting architecture, even for a company that will eventually need microservices?
Early on, the bottleneck is never infrastructure — it's product-market fit and shipping speed. A monolith means one codebase, one deployment, no network calls between your own components, and no distributed-systems failure modes to reason about. That's the right trade for a small team iterating fast, and splitting into services before you've found what's worth scaling is optimizing for a problem you don't have yet.
What specifically breaks in a monolith that forces the move to microservices?
Not performance, usually — engineering velocity. As a monolith's feature surface grows, more engineers are touching the same codebase, deploys become larger and riskier, and a bug in one feature can take down unrelated ones because everything shares the same process and deployment unit. The move to microservices is primarily a response to team-scaling and blast-radius problems, not a raw performance optimization.
Why extract only some functionality into services while orchestration logic stays centralized?
A common intermediate stage: pull specific features out into their own services for independent deployability, while the routing and coordination logic connecting them stays in one place. This captures much of the benefit (independent services, independent deploys) without yet solving the harder problem of decoupling clients from a growing, shifting set of backend services — that's what the next stage, an API gateway, is for.
What problem does an API gateway solve that microservices alone don't?
Without a gateway, clients (mobile apps, web frontends) need to know about and directly call every individual backend service, which tightly couples client code to backend topology — adding, removing, or restructuring a service means changing every client. A gateway sits between clients and services, so the backend can evolve its internal structure freely while clients keep talking to one stable, unified entry point.
Does every growing system inevitably need all three stages?
No — the three stages describe a common trajectory once growth actually forces evolution, not a mandatory checklist for every system. Plenty of products stay a well-run monolith for their entire lifetime because they never hit the team-scaling or velocity ceiling that makes splitting worth its complexity cost. The stages are a map for recognizing which problem you're actually facing, not an architecture to build toward preemptively.

/* Comments */
Comments are offline right now — we reconnect automatically, nothing is lost.