During the low-interest-rate years, "Microservices" was the fashionable buzzword of choice. Some startups with a handful of users were running a fleet of services on Kubernetes. Often it was complexity for complexity's sake. Since then, the pendulum has swung back for many teams.
The "Distributed Monolith" Trap
Many companies didn't really build microservices; they built a distributed monolith. They took function calls (which take nanoseconds) and turned them into HTTP requests (which take milliseconds) over a flaky network.
The "Whoops" Moment
A common complaint from teams in this position: more time goes into debugging distributed tracing and managing infrastructure state than into building product features.
Enter the Modular Monolith
For most new products, a strong default is the Modular Monolith.
Single Deployment Unit
One CI/CD pipeline. One database (logically separated). Atomic commits.
Strict Boundaries
Code is organized into modules (Billing, Users, Inventory) that interact via public interfaces, not backdoor SQL joins. It enforces discipline without the network lag.
When to actually split?
A useful rule of thumb: only extract a service when it has a very different scaling, reliability or ownership profile.
// Good reason to split:
"The Video Transcoding module eats all the CPU and crashes the API server." -> Move to Worker Service.
// Bad reason to split:
"We want the User Profile team to have their own repo." -> Use a Monorepo.
Simplicity usually scales better than complexity. Don't build Google's infrastructure unless you have Google's problems (and budget). If you are untangling an over-split system, our legacy modernization work covers consolidating services, and our software consulting can review an architecture before you commit to it.
