Chapter 6: The monolithic architecture
The chapter introduction explains why a monolith can remain a good choice despite the fast-flow advantages often associated with multi-component architectures.
After this chapter you will be able to
- Monolith and multicomponent tradeoff. Explain why a monolithic architecture can be a good choice even though a multi-component architecture is often needed to meet fast-flow requirements in large applications developed by large organizations.
- Monolithic application structure. Describe how the monolithic architecture structures an application as a single component, with code in one repository and one pipeline for building and deploying it.
- Single code base simplicity. Explain why a monolith’s single code base can make development simpler, including changes to code and schema, developer tooling, and compile-time API checks in compiled languages.
- Local transactional system operations. Explain why system operations in a monolith are typically easier to implement and reason about, and distinguish the common single-transaction case from the exceptions described here.
- Simple but flexible deployment. Describe why deploying a monolith is usually straightforward and how the same component can nevertheless be deployed in clusters optimized for different workloads.
- Local request troubleshooting. Explain why runtime troubleshooting is usually simpler in a monolith and when that advantage needs additional observability support.
- Monolith design discipline. Explain why a monolith can be modifiable yet is vulnerable to accumulating tight design-time coupling.
- Technology stack evolvability. Explain why changing or experimenting with a large monolith’s technology stack becomes difficult as its organization grows.
- Growing monolith testability. Describe the three reasons testing a large monolith becomes slower or less dependable.
- Monolith deployment constraints. Distinguish deployability capabilities a monolith can retain from those that become harder as it and its organization grow.
- Subdomain observability limits. Explain why observing a monolith does not necessarily reveal the behavior of each subdomain.
- Single technology stack constraint. Explain why a monolith cannot use a different language runtime and supporting libraries for each subdomain, and how that limits teams’ choice of tools.
- Subdomain isolation constraint. Explain why a monolith cannot segregate subdomains according to characteristics such as sensitivity or business criticality, in contrast to deploying them as separate services.
- Monolith Pattern Language Overview. Describe the pattern language’s high-level contrast between technology-oriented and domain-oriented monolith structures, and the role of supporting build-project patterns.
- Technology-oriented domain structure drawbacks. Explain that a monolith can be loosely design-time coupled and cohesive, but a technology-oriented domain structure often works against those qualities and can increase build-time coupling, reducing testability and deployability.
- Technology-oriented layer structure. Describe how a layered FTGO monolith organizes code by technical role rather than by subdomain.
- Growing layers and change ripple. Explain how fixed technical layers accumulate responsibilities and make subdomain changes less local as an application grows.
- Layered build-time coupling. Trace why making each layer a build project can turn a small code change into substantial rebuilding and retesting.
- Subdomain-based module structure. Describe how a modular monolith organizes its code into domain modules and a main module.
- Team ownership through alignment. Explain why organizing a monolith by subdomain can benefit teams.
- Domain module structure. Describe a domain module as a team-owned vertical slice for one subdomain, and explain how the Consumer Domain Module organizes its REST API, business logic, and database adapter.
- Facade API boundaries. Explain why other domain modules should use a small, stable facade API rather than directly invoking a module’s entities and repositories, using the Order and Consumer modules as the example.
- Database boundary exceptions. Explain the usual rule against cross-module database access and distinguish pragmatic cross-boundary SELECT queries from cross-boundary updates.
- Multi-domain entry and invocation. Explain how a multi-domain operation gets an entry point and how direct invocation lets it call other modules, including the coupling that results.
- Asynchronous follow-up actions. Explain how messaging separates order creation from follow-up actions such as email, and state the principal benefit and cost.
- Single-transaction operation strategy. Explain why transaction-per-operation is the simple default for a monolith and what trade-off it makes.
- Per-module transaction complexity. Describe how transaction-per-domain-module uses a sequence of transactions and why failed credit reservation can require compensation; explain the simpler alternative shown.
- Requirements-driven transaction boundaries. Explain when operation requirements, rather than module or operation boundaries, should determine where transactions start and end.
- Independent module testing. Explain why organizing a monolith into loosely design-time coupled domain modules improves testability and speeds feedback.
- Domain module test suite. Describe the three kinds of tests in a domain module’s test suite and how module tests isolate its dependencies.
- Limited application testing. Explain what whole-application tests verify and why they do not repeat domain module tests.
- Build-time coupling and fast flow. Explain why long builds can make a monolith harder to test and deploy, and how structuring domain modules’ build projects to minimize build-time coupling can help.
- One-to-one mapping costs. Explain how mapping each domain module to one build project can increase build-time coupling and slow testing and deployment.
- Build project design principles. State the two physical design ideas the section gives for minimizing build-time coupling between and within projects.
- Separate domain API projects. Explain how splitting a domain module into API and implementation build projects reduces build-time coupling, and describe the effect on client testing and deployment throughput.
- Interface Segregation for Domain APIs. Explain why a separate API build project can still cause unnecessary rebuilds, and how applying the Interface segregation principle limits clients to the APIs they use.
- Separate implementation build projects. Describe how to split the Order Management implementation into build projects and explain the effect on testing and feedback.
- Modular monolith benefits and limits. Explain that a modular monolith is structured to manage complexity, increase team autonomy, and accelerate deployment, but remains a monolith and is not necessarily a stepping stone to microservices.
- Limits of modularity. Explain why a modular monolith remains a monolith and why modularity cannot eliminate its build-time limits.
- Growing limits on fast flow. Describe how a growing application and organization can outgrow a modular monolith despite its advantages.
- Network unfriendly module interactions. Explain why interactions that work efficiently between modules in one process may not work well after those modules become separate services.
- Cross module transaction splitting. Explain why an operation that uses one transaction across modules must be reconsidered when those modules become separate services.
What it builds on
- (chapter intro) (chapter 5) · The five quality attributes used to express architectural requirements for fast flow.
- The Monolithic architecture can enable fast flow (chapter 1) · The earlier discussion that a monolithic architecture can enable fast flow.
- Observability: ease of understanding an application’s runtime behavior (chapter 5) · The earlier discussion of observability as understanding runtime behavior.
- Modifiability requires loose design-time coupling and high cohesion (chapter 5) · Loose design-time coupling and cohesion as requirements for modifiability.
- Architecting for high evolvability (chapter 5) · The architectural concern of maintaining evolvability.
- Testability: ease and speed of verifying releasability (chapter 5) · Automated, fast, and locally runnable testing as dimensions of testability.
- Deployability: ease, speed and reliability of deployments (chapter 5) · Deployability as ease, speed, and reliability of deployments.
- Four flavors of coupling (chapter 4) · The distinction between flavors of coupling.
Section by section
Introduction
The chapter introduction explains why a monolith can remain a good choice despite the fast-flow advantages often associated with multi-component architectures.
- Monolith and multicomponent tradeoff: Explain why a monolithic architecture can be a good choice even though a multi-component architecture is often needed to meet fast-flow requirements in large applications developed by large organizations.
Why it matters: It frames the choice of architecture as a tradeoff rather than treating either approach as universally best.
Key terms: single component architecture, monolithic architecture, multi-component architecture, fast flow
6.1 About the monolithic architecture
Defines the monolithic architecture and explains why its simplicity can make it suitable for applications, especially early in their lifetime.
- Monolithic application structure: Describe how the monolithic architecture structures an application as a single component, with code in one repository and one pipeline for building and deploying it.
Why it matters: This gives you the baseline structure for understanding the chapter’s discussion of monoliths. - Early suitability of monoliths: Explain why the monolithic architecture can be suitable for many applications, particularly early in their lifetime.
Why it matters: A monolith is not inherently a poor starting architecture.
Key terms: monolithic architecture, single component, single code repository, single deployment pipeline, simplicity
6.1.1 Benefits of the monolithic architecture
This section explains four practical benefits of a monolith: simpler development, system operations, deployment, and troubleshooting, while noting important exceptions.
- Single code base simplicity: Explain why a monolith’s single code base can make development simpler, including changes to code and schema, developer tooling, and compile-time API checks in compiled languages.
Why it matters: These advantages help explain why a monolith can be an effective starting architecture. - Local transactional system operations: Explain why system operations in a monolith are typically easier to implement and reason about, and distinguish the common single-transaction case from the exceptions described here.
Why it matters: The transaction boundary is a major practical difference between local monolith operations and operations spanning services. - Simple but flexible deployment: Describe why deploying a monolith is usually straightforward and how the same component can nevertheless be deployed in clusters optimized for different workloads.
Why it matters: A single deployable component does not require every instance to handle the same workload on identical hardware. - Local request troubleshooting: Explain why runtime troubleshooting is usually simpler in a monolith and when that advantage needs additional observability support.
Why it matters: The location of a request’s logs affects how quickly developers can investigate a runtime problem.
Key terms: single code base, compile-time enforcement of APIs, system operations, single transaction, ACID, isolation, single component, single technology stack, multi-cluster deployment, troubleshooting
6.1.2 The monolithic architecture and the quality attributes for fast flow
Explains why a small monolith can support fast flow but a monolith’s modifiability, evolvability, testability, deployability, and observability become harder to sustain as the application or organization grows.
- Monolith design discipline: Explain why a monolith can be modifiable yet is vulnerable to accumulating tight design-time coupling.
Why it matters: Being a monolith does not prevent good design, but it does not enforce it either. - Technology stack evolvability: Explain why changing or experimenting with a large monolith’s technology stack becomes difficult as its organization grows.
Why it matters: Slow or risky stack changes can leave even important upgrades unfinished. - Growing monolith testability: Describe the three reasons testing a large monolith becomes slower or less dependable.
Why it matters: These problems delay feedback about whether a change is safe to release. - Monolith deployment constraints: Distinguish deployability capabilities a monolith can retain from those that become harder as it and its organization grow.
Why it matters: A deployable monolith can still become a bottleneck for releasing many teams’ changes. - Subdomain observability limits: Explain why observing a monolith does not necessarily reveal the behavior of each subdomain.
Why it matters: Whole-application metrics may make a problem in one subdomain difficult to diagnose.
Key terms: modifiability, domain view, design-time coupling, technical debt, big ball of mud, evolvability, technology stack, single component, testability, deployment pipeline
6.1.3 Other drawbacks of monolithic architecture
This section explains two drawbacks of a monolith beyond declining fast-flow quality attributes: one technology stack for all code and no service-level isolation of subdomains.
- Single technology stack constraint: Explain why a monolith cannot use a different language runtime and supporting libraries for each subdomain, and how that limits teams’ choice of tools.
Why it matters: It explains why a team cannot freely choose a language or runtime to fit each part of a monolithic application. - Subdomain isolation constraint: Explain why a monolith cannot segregate subdomains according to characteristics such as sensitivity or business criticality, in contrast to deploying them as separate services.
Why it matters: It shows why sensitive or business-critical functionality cannot be isolated as a separately deployed service within a monolith.
Key terms: monolith, single technology stack, language runtime, supporting libraries, subdomain, subdomains, business criticality, security, separate services, structural separation
6.1.4 The monolithic architecture pattern language
This section introduces a pattern language for mitigating some monolith drawbacks through structural and build-project design while acknowledging that other limitations are inherent.
- Inherent and Mitigable Limitations: Distinguish an inherent limitation of a monolith from drawbacks that careful design can mitigate as the application and organization grow.
Why it matters: It sets realistic expectations for what improving a monolith can accomplish. - Monolith Pattern Language Overview: Describe the pattern language’s high-level contrast between technology-oriented and domain-oriented monolith structures, and the role of supporting build-project patterns.
Why it matters: It gives a high-level map of how the chapter proposes to improve a monolith.
Key terms: fast flow, single technology stack, pattern language, Technology-Oriented Monolithic Architecture pattern, Modular Monolith pattern, design-time coupling, build-time coupling
6.2 Modularizing the monolith
This introduction explains why a monolith’s traditional technology-oriented domain structure can undermine loose coupling, cohesion, testability, and deployability.
- Technology-oriented domain structure drawbacks: Explain that a monolith can be loosely design-time coupled and cohesive, but a technology-oriented domain structure often works against those qualities and can increase build-time coupling, reducing testability and deployability.
Why it matters: It distinguishes a monolith’s architectural potential from the drawbacks of a common way of structuring it.
Key terms: monolithic architecture, technology-oriented architectural style, domain view, design-time coupling, cohesion, build-time coupling
6.2.1 A technology-oriented architectural style for the domain architecture
This section shows how a technology-oriented layered monolith spreads subdomain code across layers and why that structure becomes problematic as an application and its teams grow.
- Monolithic architecture scope: Explain why the Monolithic architectural style does not, by itself, determine how a monolith’s domain is structured.
Why it matters: Being a monolith does not settle how its business code should be organized. - Technology-oriented layer structure: Describe how a layered FTGO monolith organizes code by technical role rather than by subdomain.
Why it matters: The split between technical layers and business subdomains underlies the section’s drawbacks. - Growing layers and change ripple: Explain how fixed technical layers accumulate responsibilities and make subdomain changes less local as an application grows.
Why it matters: A small business change can become work spread across large, shared layers. - Subdomain team misalignment: Explain why technical layers can create friction for teams organized by subdomain.
Why it matters: The code’s divisions can make everyday work awkward when they do not match team ownership. - Layered build-time coupling: Trace why making each layer a build project can turn a small code change into substantial rebuilding and retesting.
Why it matters: Build-project boundaries can make the edit-test cycle slow even for minor changes.
Key terms: Monolithic architectural style, component view, build view, domain view, technology-oriented, layered architecture, web, domain, persistence, subdomain
6.2.2 Introduction to the modular monolith
This section introduces the modular monolith as a monolith organized by subdomain and explains how that organization can give teams clear ownership of their code.
- Subdomain-based module structure: Describe how a modular monolith organizes its code into domain modules and a main module.
Why it matters: This is the organizing principle behind the modular monolith described in the section. - Domain versus technical organization: Distinguish subdomain-based organization from layered and hexagonal organization as described in this section.
Why it matters: The contrast clarifies that the difference is what the code is organized around, not whether it has structure. - Team ownership through alignment: Explain why organizing a monolith by subdomain can benefit teams.
Why it matters: The section presents clear team ownership as a key benefit of the modular monolith.
Key terms: modular monolith, subdomains, domain modules, main module, layered architecture, Hexagonal architecture, domain-oriented architecture, technical concepts, domain architecture, organization’s structure
6.2.3 Domain module design
This section explains how to structure a domain module and limit coupling through its internal architecture, API, and database boundaries.
- Domain module structure: Describe a domain module as a team-owned vertical slice for one subdomain, and explain how the Consumer Domain Module organizes its REST API, business logic, and database adapter.
Why it matters: This structure keeps responsibility for a subdomain clear while giving its different kinds of logic distinct places. - Facade API boundaries: Explain why other domain modules should use a small, stable facade API rather than directly invoking a module’s entities and repositories, using the Order and Consumer modules as the example.
Why it matters: A narrow API lets one module change its internals without making its clients depend on those details. - Database boundary exceptions: Explain the usual rule against cross-module database access and distinguish pragmatic cross-boundary SELECT queries from cross-boundary updates.
Why it matters: The distinction preserves ownership of business rules without making every cross-domain read needlessly complicated.
Key terms: domain module, subdomain, vertical slice, hexagonal architecture, inbound adapter, outbound adapter, design-time coupling, facade-style API, ConsumerService, ConsumerRepository
6.2.4 Designing system operations that span domains
This section explains how a modular monolith coordinates system operations across domain modules and chooses transaction boundaries for those operations.
- Multi-domain entry and invocation: Explain how a multi-domain operation gets an entry point and how direct invocation lets it call other modules, including the coupling that results.
Why it matters: The choice of entry point and calls determines which modules must change together and which work can delay a request. - Observer collaboration trade-offs: Describe how notifications let other domain modules react to order creation, and distinguish the design-time and runtime coupling that remains.
Why it matters: Notifications can separate secondary actions from order logic without removing the risk that a slow observer delays the operation. - Asynchronous follow-up actions: Explain how messaging separates order creation from follow-up actions such as email, and state the principal benefit and cost.
Why it matters: Messaging prevents a secondary external service from blocking the core order operation, but it is not a free simplification. - Single-transaction operation strategy: Explain why transaction-per-operation is the simple default for a monolith and what trade-off it makes.
Why it matters: This simple consistency option is the baseline against which the section weighs multi-transaction designs. - Per-module transaction complexity: Describe how transaction-per-domain-module uses a sequence of transactions and why failed credit reservation can require compensation; explain the simpler alternative shown.
Why it matters: Separate transactions may impose compensation work that the monolith’s single-transaction option can avoid. - Requirements-driven transaction boundaries: Explain when operation requirements, rather than module or operation boundaries, should determine where transactions start and end.
Why it matters: Transaction boundaries should fit an operation’s constraints rather than follow one architectural rule everywhere.
Key terms: entry point, Invoke, design-time coupled, runtime coupled, Observer pattern, subject, observer, notification, asynchronous messaging, message channel
6.2.5 Testing strategy for a modular monolith
A modular monolith improves testability by testing loosely coupled domain modules independently and keeping whole-application tests limited to integration checks.
- Independent module testing: Explain why organizing a monolith into loosely design-time coupled domain modules improves testability and speeds feedback.
Why it matters: Testing only what a change affects can make feedback and deployment faster. - Domain module test suite: Describe the three kinds of tests in a domain module’s test suite and how module tests isolate its dependencies.
Why it matters: These test types let a module’s behavior be checked without relying on a full-application test. - Limited application testing: Explain what whole-application tests verify and why they do not repeat domain module tests.
Why it matters: Keeping slow application tests focused avoids duplicating checks already made within modules.
Key terms: modular monolith, domain modules, design-time coupling, edit-compile-analyze loop, unit tests, integration tests, module tests, test doubles, adapter classes, application tests
6.3 Minimizing build-time coupling to improve testability and deployability
This section explains why reducing build-time coupling in a modular monolith can improve testability, deployability, and fast flow.
- Build-time coupling and fast flow: Explain why long builds can make a monolith harder to test and deploy, and how structuring domain modules’ build projects to minimize build-time coupling can help.
Why it matters: It connects build structure to the speed of testing and deploying changes.
Key terms: build-time coupling, modular monolith, domain module, testability, deployability, fast flow
6.3.1 About physical design principles
The section explains why mapping each domain module to one build project can slow builds and introduces physical design principles for reducing build-time coupling.
- One-to-one mapping costs: Explain how mapping each domain module to one build project can increase build-time coupling and slow testing and deployment.
Why it matters: It explains why an apparently simple project layout can slow both developer feedback and deployment. - Logical and physical design: Distinguish logical design from physical design in this section's account of a modular monolith.
Why it matters: A well-organized domain model does not by itself guarantee an efficient build structure. - Build project design principles: State the two physical design ideas the section gives for minimizing build-time coupling between and within projects.
Why it matters: These principles guide project boundaries so changes need not trigger unnecessary testing and rebuilding.
Key terms: domain module, build project, build-time coupling, transitive dependencies, logical design, physical design, design-time coupling, physical design principles, stable projects, tested together
6.3.2 Define build projects for domain module APIs
This section shows how separating a domain module’s API and implementation into build projects reduces build-time coupling and retesting.
- Separate domain API projects: Explain how splitting a domain module into API and implementation build projects reduces build-time coupling, and describe the effect on client testing and deployment throughput.
Why it matters: Keeping clients coupled to stable interfaces makes implementation changes cheaper to test and deliver.
Key terms: domain module, API build project, implementation build project, build-time coupling, test double, edit-test-analyze cycle
6.3.3 Apply the Interface segregation principle
This section shows how splitting a domain module’s API by client needs reduces unnecessary build-time coupling and retesting.
- Interface Segregation for Domain APIs: Explain why a separate API build project can still cause unnecessary rebuilds, and how applying the Interface segregation principle limits clients to the APIs they use.
Why it matters: Narrower API dependencies prevent unrelated changes from triggering client rebuilds and tests.
Key terms: Interface segregation principle, build-time coupling, API build project, ConsumerService, CreditManagement, common types
6.3.4 Segregate implementation build projects
Separating a domain module’s implementation into build projects avoids unnecessary test runs and speeds up development and deployment feedback.
- Implementation build-time coupling: Explain why API build projects do not eliminate build-time coupling within a domain module’s implementation. Describe how placing unrelated packages in one build project causes tests to run unnecessarily.
Why it matters: It explains why separating a module’s API from its implementation may not make testing fast enough. - Separate implementation build projects: Describe how to split the Order Management implementation into build projects and explain the effect on testing and feedback.
Why it matters: The split speeds feedback in both the local edit-test-analyze cycle and the deployment pipeline.
Key terms: build-time coupling, design-time, implementation build project, implementation build projects, domain build project, edit-test-analyze cycle, deployment pipeline
6.4 The limitations of the modular monolith
This introduction presents the modular monolith as an improvement over a layered monolith while setting limits on what that improvement implies.
- Modular monolith benefits and limits: Explain that a modular monolith is structured to manage complexity, increase team autonomy, and accelerate deployment, but remains a monolith and is not necessarily a stepping stone to microservices.
Why it matters: It prevents the benefits of modularization from being mistaken for the benefits of a different architecture.
Key terms: modular monolith, traditional layered monolith, microservice architecture
6.4.1 A modular monolith is still a monolith
This section explains why modularity improves a monolith without removing the architectural limits that may eventually impede fast flow.
- Limits of modularity: Explain why a modular monolith remains a monolith and why modularity cannot eliminate its build-time limits.
Why it matters: Modular boundaries help, but they do not make every change cheap to build or deploy. - Growing limits on fast flow: Describe how a growing application and organization can outgrow a modular monolith despite its advantages.
Why it matters: The relevant question is whether the monolith still supports fast flow as the application and organization grow.
Key terms: modular monolith, worst case build time, testability, deployability, evolvability, observability, fast flow
6.4.2 The myth of the microservices-ready modular monolith
A modular monolith’s domain modules cannot necessarily be extracted into services without redesigning their interactions and transactions.
- Network unfriendly module interactions: Explain why interactions that work efficiently between modules in one process may not work well after those modules become separate services.
Why it matters: Modular boundaries alone do not guarantee that existing interactions will work well across a network. - Cross module transaction splitting: Explain why an operation that uses one transaction across modules must be reconsidered when those modules become separate services.
Why it matters: A modular monolith’s transaction boundary cannot simply be carried over when its modules become services.
Key terms: domain modules, method calls, service-to-service communication, runtime coupling, ACID transaction, local to each service, Saga pattern, consistency, rollback
6.5 Summary
Where this is used later
- Operational challenges (chapter 7) · The monolithic architecture used as the operational comparison.
- Overview of the microservice architecture pattern language (chapter 7) · the monolithic architecture as an architectural alternative
- ACID transactions in a microservice architecture (chapter 9) · The contrast with transactions across services provides context for transaction management in a microservice architecture.
- (chapter intro) (chapter 7) · The earlier discussion relates the monolithic architecture to the quality attributes for fast flow.
- Supports multiple technology stacks (chapter 7) · Provides a contrast for support of multiple technology stacks.
- Enables segregation of subdomains by characteristics (chapter 7) · Provides the monolithic limitation against which segregation of subdomains is compared.
- Overview of messaging (chapter 8) · develops messaging as a communication mechanism
- The structure of a saga (chapter 9) · expands on the structure of sagas composed of transactions
Concepts explained in this chapter
- monolithic architectureAn architecture in which an application is built and deployed as a single unit.
- domain moduleA cohesive application module corresponding to a business subdomain and containing its business, interface, and infrastructure logic.
- modular monolithA modular monolith is a monolithic application organized into independently structured modules with explicit boundaries and limited coupling.
- asynchronous communicationA messaging technique in which a sender continues processing without waiting for an immediate reply.
- compensating transactionA transaction that semantically undoes the effects of a previously committed transaction.
- invoke patternThe invoke pattern is a collaboration mechanism in which one domain module synchronously calls a method on another domain module.
- observer patternA behavioral design pattern in which observers subscribe to notifications published by a subject whose state or activity changes.
- requirements-driven transaction boundariesRequirements-driven transaction boundaries define transaction scope according to the specific consistency, performance, and integration requirements of each operation.
- transaction management strategyA transaction management strategy defines how transaction boundaries and consistency responsibilities are organized for a system operation.
- transaction-per-domain moduleTransaction-per-domain module is a transaction strategy that gives each domain module's work its own transaction.
- transaction-per-operationTransaction-per-operation is a transaction strategy that executes an entire system operation within one transaction.
- build-time couplingLoose build-time coupling is a build dependency property in which changing a build module requires relatively few other subprojects to be recompiled and retested.
- evolvabilityEvolvability is the ability of an application or its technology stack to be changed, upgraded, or experimented with rapidly and independently.
- observabilityObservability is the degree to which an application's runtime behavior and user-impacting effects can be understood from its externally visible outputs.
- database transactionA unit of work whose operations execute under defined consistency and completion semantics.
- technology-oriented architectural styleA technology-oriented architectural style organizes an application primarily around technical concerns or infrastructure layers rather than business domains.
- subdomainA coherent area of business responsibility within a larger domain.
- contractAn interface that defines how software components interact and access one another's functionality.
- domain architectureDomain architecture is the internal organization of a domain module's business logic and its interfaces to external concerns.
- facade-style apiAn API that exposes a limited set of operations while hiding the implementation details of the component behind it.
- schemaA formal definition of the fields, types, and structural rules of a message or data object.
- vertical sliceA vertical slice is an architectural partition that cuts through multiple layers to contain the functionality for a specific business capability.
- layered architectureAn architectural style that organizes software elements into layers with defined responsibilities and constrained dependencies.
- modifiabilityModifiability is a system's ability to support changes in its behavior or other qualities after initial deployment.
- tight couplingA relationship in which software elements have substantial dependencies on one another.
- test doubleA test double is a substitute component that simulates the behavior of a real collaborator or dependency during testing.
- unit testA unit test verifies a small, isolated unit of software behavior, typically executing quickly within a local development environment.
- nondistributed transactionA local transaction is a transaction whose scope is restricted to the data and resources managed by one service.
- microservice architectureAn architectural style that structures an application as a collection of independently deployable services aligned with business capabilities.
- serviceA software component that provides a cohesive set of capabilities within an application.
- technology stackThe combination of programming languages, runtimes, frameworks, libraries, and supporting technologies used to build and run an application or service.
- Gradle ProjectA configuration and set of tasks that transforms source code into compiled or packaged software artifacts.
- edit-test-analyze loopThe edit-test-analyze loop is an iterative development cycle in which a developer changes code, runs tests, and examines the results.
- autonomyTeam autonomy is a team property in which the team can perform its work with minimal dependence on coordination, hand-offs, or waiting on other teams.
- fast flowThe rapid movement of software changes from development into production, supported by rapid feedback.
- channelA communication path through which messages are sent and received.
- handlerAn event handler is a software component that receives an event and performs the associated processing.
- canary deploymentA canary release runs a new software version alongside the current version and initially routes only a small share of traffic to it.
- business criticalityBusiness criticality is the degree to which a software capability is essential to an organization's business operations or value generation.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
