Course contentsShow
← System Design
Lesson 789 of 1,91921. Microservices ArchitectureFree lesson

The Distributed Monolith Anti-Pattern

A distributed monolith has microservices architecture but retains tight coupling, combining the worst of both worlds.

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.