Oct 30, 2026 · 10 min read
Microservices or Monolith: How to Actually Decide
Most teams adopt microservices for the wrong reasons. Here's a practical framework for when microservices actually help, when they don't, and what to do instead.
Every few years, the microservices debate comes back. Teams read about Netflix or Uber, decide they need the same architecture, and end up with a distributed monolith that's harder to deploy than what they started with.
The problem isn't microservices. The problem is adopting them for the wrong reasons.
The wrong reasons
"Modern applications use microservices." This is the worst reason. It's circular. Microservices are modern because they're used by modern companies, and they're used by modern companies because those companies have specific problems that microservices solve. If you don't have those problems, you don't need the solution.
"We're moving to the cloud." Cloud deployment doesn't require microservices. You can deploy a monolith to AWS, GCP, or Azure just fine. The cloud makes microservices easier to operate, but it doesn't make them necessary.
"It will solve our scaling problems." Maybe. But poor performance is usually caused by poor database design, inefficient algorithms, or network latency, not by monolithic architecture. If your database is the bottleneck, splitting your application into 12 services that all talk to the same database doesn't help.
"It will make our team more productive." Microservices add operational complexity: more deployments, more monitoring, more network failure modes, more distributed debugging. If your team is struggling with productivity in a monolith, adding distributed systems complexity won't fix it. It will make it worse.
When microservices actually help
Microservices are a response to specific problems. If you have these problems, they're worth the cost.
Your application has grown too large for one team to own. When a codebase gets big enough that multiple teams are stepping on each other's toes, merging conflicts constantly, and deployment coordination becomes a weekly meeting, microservices let each team own and deploy their piece independently. This is the single best reason to adopt them.
Different parts of your application have different scaling profiles. If your search endpoint gets 10x the traffic of your billing endpoint, scaling them independently saves money and reduces blast radius. In a monolith, you scale the whole app to handle the peak load of the busiest endpoint.
You need different technology stacks for different components. Maybe your ML inference layer is better in Python and your API layer is better in Go. Microservices let you pick the right tool for each job without forcing everything into one language.
Deployment frequency is bottlenecked by a single artifact. If every team has to wait for the monolith to be built, tested, and deployed, and that cycle takes hours, splitting into services lets teams move at their own pace.
The monolith-first approach
For a new application, start with a monolith. Almost every experienced architect says this, and almost every team ignores it.
Here's why it's right: when you're building something new, you don't know your domain boundaries yet. You don't know which parts will need to scale independently. You don't know which teams will own which pieces. If you split into microservices on day one, you'll guess wrong, and those wrong guesses are expensive to fix.
A modular monolith gives you the same separation of concerns (clean module boundaries, independent testing) without the distributed systems overhead. When you hit a real scaling or organizational problem, you can extract a service from the monolith. That extraction is easier from a well-structured monolith than from a tangled one.
The ACM's 2024 study on adopting microservices put it directly: "We do not recommend creating a new green-field application using a microservice architectural style. It is too complicated to start that way."
The hidden costs
Teams underestimate what microservices cost to operate. Here's the real list:
-
Network failure modes. Every service-to-service call can timeout, fail, or return partial data. You need retries, circuit breakers, and fallback logic. In a monolith, a function call either works or throws.
-
Distributed transactions. In a monolith, you can wrap a multi-step operation in a database transaction. In microservices, you need sagas, eventual consistency, or distributed transaction coordinators. Each one adds complexity and failure modes.
-
Observability. When a request spans five services, you need distributed tracing, centralized logging, and service mesh instrumentation to understand what happened. In a monolith, you have a stack trace.
-
Deployment complexity. One service is one deployment. Ten services are ten deployments, ten CI pipelines, ten rollback procedures, and version compatibility between them.
-
Latency. A function call takes nanoseconds. A network call between services takes milliseconds. Add that up across a request path and you've added hundreds of milliseconds to your response time.
A practical framework
Instead of asking "monolith or microservices?", ask these questions in order:
-
How many teams will work on this? One team: monolith. Multiple teams stepping on each other: consider extraction.
-
What's the actual scaling bottleneck? If it's the database, microservices won't help. If it's a specific component that needs to scale independently, extract that component.
-
What's the deployment cadence? If you need to deploy one part multiple times a day and another part once a month, separating them makes sense. If everything deploys together anyway, keep it together.
-
Can you maintain clean module boundaries in a monolith? If yes, do that. If your team can't maintain module boundaries in a monolith, they won't maintain service boundaries in microservices either. The problem is discipline, not architecture.
-
What's the cost of the distributed system? Add up the observability tooling, the network complexity, the deployment pipelines, the on-call burden. Is the benefit worth it?
The spectrum, not the binary
Forrester's research makes the right point: this isn't a binary choice. Architectures exist on a spectrum. You can have a modular monolith with one or two extracted services for the components that genuinely need independent scaling. You can have a service-oriented architecture without going full microservices. You can start with a monolith and extract services as real problems emerge.
The teams that succeed with microservices are the ones that extracted them from a monolith when they had a concrete reason. The teams that struggle are the ones that started with microservices because they thought they should.
Start with a monolith. Keep it clean. Extract when you have a real problem. That's the whole framework.