liveBook · Manning

Modular monolith

As explained in Software Architecture Decision-Making

A modular monolith is a deployable monolithic application organized into explicit internal modules with controlled boundaries.

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

How Software Architecture Decision-Making covers it

How deep it goes
Defines the pattern and contrasts it with distributed monoliths, while deferring implementation mechanics for enforcing module boundaries.
Examples
Uses a one-team internal workflow with simple integration adapters, testable business rules, and no initial workflow engine.
What you can do after
Evaluate/understand when to start with a modular monolith and which signals justify later distribution.
How it connects
Connects modular monoliths to microservices, domain boundaries, team ownership, independent deployment, observability, and adapters.

Also explained in

Compare how 3 books explain modular monolith →

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Software Architecture Decision-Making. The section links point to the parts of the book it draws on.