A modular monolith is a single deployable system with clear internal boundaries between modules. It separates responsibilities without immediately taking on network-level coordination, deployment, integration, and operational complexity. This makes it a practical starting point when the domain is still being understood, one team owns most of the work, and distributed-system operations are not yet a strength. section 2.1 section 4.5.1
The pattern is not an anti-microservices position. It is a choice to delay distribution until its benefits are real: independently owned areas, distinct release cadences, genuinely different scaling or resilience needs, and teams able to operate services end to end. Until then, distribution can create a distributed monolith: services that retain shared data, synchronized changes, unclear ownership, fragile contracts, and operational dependencies. section 2.1 section 4.5.1
Use a modular monolith when the current constraints favor simpler delivery:
- One team owns most of the system, while domain boundaries and future needs are still emerging. section 2.1
- Independent deployment is not necessary, and scaling needs do not clearly differ between parts of the system. section 2.1
- Operational maturity is limited, particularly for observability, tracing, and incident response across distributed components. section 2.1
- The main risk is delivery complexity rather than demonstrated runtime scale or divergent resilience requirements. section 2.1
A narrow internal workflow
For a narrowly scoped workflow owned by one team, clear internal workflow boundaries can be sufficient without five independently deployed services. Keep business rules out of controllers and infrastructure code, isolate known integrations behind simple adapters, and make rules easy to test. Strengthen adapters or introduce a workflow engine only when concrete integrations or variations justify them. Spend early rigor on decisions that are expensive to retrofit, including deployment, configuration, observability, data ownership, and security boundaries. section 3.1
Modularity preserves options only when boundaries are explicit and maintained. Avoid scattering integration dependencies through core logic, hard-coding local assumptions that constrain later change, or introducing abstractions solely for hypothetical futures. Prefer small seams and decision records where evidence is weak; revisit choices as ownership, operating capability, scaling, release, or resilience signals change. section 3.1 section 4.5.1
Table 4.3 Modular vs. distributed monolith
|
Modular
monolith
|
Distributed
monolith
|
|
Single
deployable system with clear internal boundaries between modules. It can
evolve well because responsibilities are separated without immediately
introducing network-level complexity.
|
Mimics microservice but services
remain tightly coupled through shared assumptions, synchronized changes,
fragile contracts, or operational dependencies. It introduces a higher cost
of distribution without the real benefit of evolution
|
Compare the single-deployable, bounded structure with the tightly coupled service arrangement that pays distribution costs without operational autonomy. section 4.5.1


