The monolith had been causing trouble for eight years: deployments that took hours, one team stepping on another's code, the permanent feeling that any change broke something far away. The decision seemed obvious: microservices. Two years later there are fourteen services, three databases, an event bus and a deployment that requires coordinating four people. The site loads slower than before and nobody remembers why the notifications service needs its own queue anymore.
The problem wasn't microservices: it was misdiagnosing the disease. Microservices solve specific problems — of teams, of scaling, of deployment cadence — and they charge a very expensive fixed toll. This guide is about when the toll is worth paying and when the well-built monolith wins by a landslide.
What Problem They Actually Solve
A microservice isn't a unit of code: it's a unit of independence. It deploys alone, scales alone, fails alone and is maintained by one team without asking anyone's permission. Everything else — size, line count, "one service per entity" — are heuristics that confuse more than they help.
When that independence answers a real need, microservices pay off:
- Teams blocking each other. If four teams share a monolith and every deployment requires coordinating all of them, splitting by domains restores autonomy. It's the original reason and the strongest one: microservices are an organisational solution, not a technical one.
- Very uneven scaling. If the image processor needs twenty machines on Fridays and the rest of the system runs fine on two, splitting it out lets you scale only what's needed. Real, measurable savings.
- Different rates of change. The payment gateway changes weekly and the country catalogue, once a year. Separating what changes fast from what doesn't reduces the risk of every deployment.
- Different availability requirements. If checkout can never go down and the reporting dashboard can afford an hour of outage, they shouldn't share a fate.
The Fixed Toll (and It Isn't Small)
Every new service pays a permanent rent, whether you use it or not:
- The network becomes your problem. A function call that cost nanoseconds is now HTTP with latency, timeouts, retries and the ever-present possibility of failure. And it will fail.
- Data gets distributed. Goodbye to transactions that span tables, hello to eventual consistency, sagas and reconciliations. It's the same conceptual leap we covered in CQRS and event-driven: complexity doesn't disappear, it moves.
- Deployments get coordinated. Changing a contract between services requires versioning, backward compatibility and publication order. What used to be a commit is now a plan.
- Debugging demands distributed tracing. Following an error across five services without correlation IDs or traces is looking for a needle in fourteen haystacks. As we saw in observability for small teams, that infrastructure costs money too.
- Failures become partial. In a monolith, it either works or it doesn't. With microservices, 80% works and somebody has to decide what the interface does when the remaining 20% doesn't respond.
The honest rule: if that toll returns nothing in exchange, you're paying rent on a flat you don't live in.
The Signs That Say Yes
- Several teams, one bottleneck. The main pain is organisational and it already hurts: blocked deployments, teams waiting on others, fuzzy responsibilities.
- Domains with clear boundaries. Invoicing, catalogue and notifications change for different reasons and share little. That's a bounded context, and drawing it well is what Domain-Driven Design is for.
- Metrics that justify it. There are numbers on uneven scaling, deployment frequency or time lost to coordination. Without numbers, it's an expensive hunch.
- A team with distributed craft. They've already operated queues, retries, eventual consistency and traces. The first time shouldn't be on the system that pays the salaries.
The Signs That Say No
- Small team or young system. With three developers, coordination is solved by talking. And a young system doesn't yet know where its boundaries are: cutting in the wrong place produces coupled services that must be deployed together — the worst of both worlds.
- "The monolith is a mess". A tangled monolith isn't fixed by distributing it: it becomes a distributed tangle, same thing but with a network. First you organise it into modules, then you decide whether any deserves independence.
- "To scale". Scaling a monolith means replicating it behind a load balancer: it solves 90% of load problems for 10% of the cost. Microservices scale by parts, but most systems never need to scale parts.
- Fashion or résumé. If the argument is that Netflix uses them, remember Netflix has thousands of engineers and problems you don't have. Copying the solution without the problem is collecting tolls.
The Sensible Path: Modular Monolith First
There's an intermediate stage almost nobody advertises because it doesn't sell conference tickets: the modular monolith. One deployment, one database, but internal modules with explicit boundaries — each with its domain, its rules and its internal API, no calls sneaking underneath. That's exactly what hexagonal architecture enables: ports and adapters isolating the domain from infrastructure.
With that internal order, extracting a module into a microservice when the need arrives is a matter of days: the boundary already exists, only the transport changes. Without that order, microservices are moving house before the house is built. The practical advice: build the boundaries before you need them; pay for distribution only when you need it.
Common Mistakes
- Microservices per entity. One service per database table produces a distributed system with the cohesion of a monolith and all its extra costs. Services are cut by domain and by team, not by entity.
- A shared database "for now". Five services writing to the same tables is a distributed monolith: total coupling with network latency. It's the worst possible configuration and the most common one in badly done migrations.
- The first version already distributed. Starting a new product with microservices means paying the toll before knowing whether there's a business. Most successful products started monolithic and distributed when the pain asked for it.
- No minimum platform. Per-service CI/CD, observability, configuration and secrets management aren't optional in a distributed system. If there's no budget for that platform, there's no budget for microservices.
- Counting services as an achievement. "We already have twenty microservices" isn't a success metric: it's a spending metric. Success is deploying without coordination, scaling only what's needed and failing without taking everything down.
In Short
Microservices buy independence — of deployment, of scaling, of teams — and charge a fixed toll in networking, distributed data, operations and debugging. They're worth it when several teams block each other, domains have clear boundaries and metrics justify them; they're overkill in small teams, young systems and monoliths whose problem was disorder, not shape. The healthy path is modular monolith first: clear boundaries today, distribution when it hurts tomorrow.
If you're weighing up splitting your system — or already split it and the toll exceeds the benefit — an architecture audit puts it in numbers: what to separate, what to join and in which order. Let's talk →
Keep reading: What is Domain-Driven Design: a practical guide with a real example.