SOFTWARE ARCHITECTURE
Post-Microservices: The Return to the Majestic Monolith
2 MIN READ
Analyzing the industry shift away from complex microservice architectures and the tools enabling highly scalable monolithic design.
The real cost of a network boundary
Microservices solve a real problem: they let many teams deploy independently. They also replace a function call with a network request, and that one change brings timeouts, retries, partial failures, versioned contracts and distributed tracing. Those are reasonable costs for an organisation that needs independent deployment. For a team of eight, they can absorb more effort than the product itself.
What a modern monolith looks like
A well-built monolith is not a tangle. It is one deployable application with strong internal boundaries, where each module owns its tables and exposes a clear interface to the others. Tools that check imports at build time can enforce those boundaries, which gives much of the discipline people want from services without the operational weight.
One deployable also means one transaction when you need it, one place to look when something breaks, and refactors that a compiler can verify across the whole system.
It can scale further than you expect
Horizontal scaling behind a load balancer, read replicas, caching and background job queues take a monolith a long way. Heavy work can move into separate worker processes that share the same codebase, so you scale the hot path without creating a new service to version and operate.
When to split anyway
Some reasons to extract a service remain strong. A component may need a very different scaling profile, such as model inference on GPUs. It may need a stricter security or compliance boundary. Or a team may have grown large enough that sharing one release train is the bottleneck.
The important change is the default. Start with a modular monolith and treat each new service as a decision that needs a specific reason. Module boundaries that are already clean make that later extraction far easier than untangling a system that was split too early.