This decision gets made for the wrong reasons more often than almost any other in software. Teams adopt microservices because large companies use them, then discover they have taken on the operational burden of a large company without the problem that justified it.
What Each One Actually Optimises For
A monolith optimises for simplicity. One codebase, one deployment, usually one database. A call between two parts of the system is a function call: fast, reliable, and impossible to half-complete. When something breaks there is one place to look.
Microservices optimise for independence. Separate teams own separate services and deploy on their own schedule without coordinating with anyone. Each service can use the tools that suit it and scale on its own curve.
That is the whole trade. Everything else follows from it — and crucially, the benefit microservices provide is organisational. If you do not have several teams blocking each other, you are paying for a solution to a problem you do not have.
The Costs, Stated Plainly
These are not reasons to avoid microservices. They are the invoice.
- Every call can now fail. A function call either runs or does not. A network call can be slow, time out, or succeed on one side and fail on the other. Every boundary needs retries, timeouts and a plan for partial failure.
- Debugging crosses machines. One request touching six services leaves six log files. Without distributed tracing you are reconstructing events by hand.
- Consistency becomes your problem. A transaction in one database is free. The same operation across four services is a distributed-systems exercise.
- Local development gets heavy. Running the system now means running many things, or maintaining mocks that drift from reality.
- Everything multiplies. Deployment pipelines, dashboards, alerts, on-call surface area, dependency upgrades.
A small team paying all of that to run a system one person could hold in their head has made themselves slower in exchange for a diagram that looks modern.
The Signals That Actually Justify a Split
- Teams are blocking each other. Releases get batched, deploys wait for someone else's testing, a change needs three teams to agree. This is the real signal, and it is organisational.
- One component has genuinely different scaling needs. Video processing beside a settings page. Splitting lets you scale the expensive part alone.
- Hard isolation is required. Regulatory separation, or a component whose failure must not reach the rest.
- Genuinely different technology is needed for one part — a real machine-learning pipeline beside a web application.
Notice what is missing: scale alone. A monolith on adequate hardware serves a great deal of traffic. Scale is usually a database problem long before it is an architecture problem.
The Approach That Usually Wins
Start with a well-structured monolith, and keep it that way. One deployable unit, but strict internal boundaries: separate modules per business domain, communicating through defined interfaces, never reaching into each other's tables.
This gives you most of what people want from microservices — clear ownership, comprehensible components, testability — without the network between them. And if a genuine need to split appears, the boundaries already exist and the seams are obvious. Teams that skip this discipline and later try to carve up a tangle find the split far harder than building services from the outset would have been.
Deciding what to build yourself at all comes first — our guide to build versus buy covers that.
If you do split
- Split along business domains, not technical layers. A service per domain works; a service for "the database layer" does not.
- One service at a time, starting with the part that most needs independence.
- Each service owns its data. Services sharing a database are a monolith with extra latency.
- Invest in observability before you need it. Tracing and centralised logging are not optional once requests span services.
- Containers and orchestration become relevant here, not before — see what Docker is and Kubernetes explained, and serverless containers versus Kubernetes for how to run them.
Key Takeaways
- Microservices solve a coordination problem between teams, not a technical one.
- The cost is distributed systems: partial failure, tracing, consistency, heavier local development.
- Scale alone is rarely the reason — that is usually a database question.
- Start with a modular monolith and split along domain seams when teams genuinely block each other.
- Services that share a database are a monolith with added latency.
Written by the WritePures newsroom. Spotted something that needs updating? Tell our editors.
0 Comments
Join the conversation
Replying toNo comments yet. Be the first to share your thoughts.