The Distributed Monolith Anti-Pattern
What you'll learn: How splitting a system into microservices can accidentally create something worse than a monolith—a distributed monolith.
The Problem
A distributed monolith occurs when you've adopted microservices architecture—multiple services, separate deployments—but these services remain tightly coupled behind the scenes. You get all the complexity of distributed systems (network calls, deployment coordination, debugging across services) without gaining the key benefits of microservices (independent deployability, isolated failures, team autonomy).
Think of it like converting a single-family home into separate apartments but leaving all the plumbing and electrical systems interconnected. You've created multiple units, but any repair still requires coordinating with everyone and shutting down the whole building.
Common Symptoms
Tight coupling manifests as:
- Services that must deploy together in lockstep (defeating independent deployability)
- Shared databases between multiple services
- Synchronous call chains where Service A → B → C → D must all be running
- Breaking changes rippling across many services simultaneously
- Inability to update one service without coordinating with three others
Why It Happens
Teams often create distributed monoliths when they split a monolith by technical layers rather than business capabilities, or when they migrate quickly without redesigning service boundaries. The architecture diagram shows microservices, but the behavior is still monolithic.
The Impact
You've traded the deployment simplicity advantage of monoliths for network complexity, while losing the independent deployability promise of microservices. It's genuinely worse than either architecture done properly.
Key Takeaway: A distributed monolith combines the worst of both worlds—microservices complexity with monolithic coupling. Proper service boundaries and loose coupling are more important than simply splitting code into multiple deployments.