Chapter 5: Architectural requirements for fast flow
The introduction frames fast flow as an architectural concern and identifies five quality attributes for assessing it.
After this chapter you will be able to
- Five fast flow quality attributes. Describe a quality attribute as a measurable, desirable application property defined through specific scenarios, and distinguish the five attributes by what each makes easier: changing the application, evolving its technology stack, verifying releasability, deploying changes, or understanding runtime and user behavior.
- Nested development feedback loops. Trace the outer change-deploy-analyze loop and the developer’s nested edit-test-analyze loop, including where feedback comes from.
- Speed across workflow steps. Explain why fast flow requires every step of the development workflow to be fast and straightforward.
- Decision scope and speed. Explain why the number of people affected by a design decision affects how quickly it can be made, and why localized changes help.
- Change enabling quality attributes. Describe the architectural properties that speed design decisions and identify the roles of modifiability and evolvability.
- Rapid implementation feedback loop. Trace how developers implement a change through the edit-test-analyze loop and explain what lets them iterate rapidly.
- Fast per-change deployment pipeline. Trace how a pushed change moves through the deployment pipeline and explain why short lead time and processing changes individually matter for prompt feedback.
- Production feedback and observability. Explain why developers need feedback after deployment and how observability helps them understand an application’s behavior in production.
- Modifiability and fast flow. Explain why fast flow requires an application architecture with high modifiability.
- Localized and autonomous changes. Explain why modifiability for fast flow calls for teams to make changes without regularly involving other teams, to keep changes within a component where possible, and to find their subdomains straightforward to change.
- Localized Changes and Team Autonomy. Explain why loose design-time coupling and high cohesion make changes more local, and how loose coupling between teams’ subdomains lets teams work mostly independently.
- Meaning of evolvability. Explain that evolvability describes how easy it is to change an application’s technology stack, and distinguish such changes from ordinary modifications by their potentially widespread impact.
- Private and shared technology stacks. Distinguish a component’s private technology stack from technologies shared across components, and explain how components can use different technologies or versions.
- Technology relationships and compatibility. Explain the requires, excludes, and provides relationships between technologies or versions, and why those relationships make assembling a compatible stack difficult.
- Cross-team upgrade bottleneck. Explain why a framework upgrade needed by one team can be difficult in a shared monolith, even when the feature’s code changes are confined to one subdomain.
- Independent and urgent upgrades. Describe the scenarios in which a team upgrades a subdomain’s library without coordinating with other teams and an organization rapidly upgrades a vulnerable library; explain why the latter also depends on quick testing and deployment.
- Incremental technology migrations. Describe how a widely used library upgrade or a database migration can proceed one team and subdomain at a time rather than as one application-wide task.
- Component-local upgrades and vulnerabilities. Explain why technology stack elements private to a component can be upgraded by that component’s team, and why a vulnerable library used by only some components requires upgrades only to those components. Distinguish these cases from technology shared across components, which requires coordination.
- Incremental application-wide upgrades. Explain how a multi-component architecture lets teams split even an application-wide framework or JVM upgrade into component-specific tasks rather than upgrading the whole application at once.
- Repeated shared upgrades. Explain the trade-off that some upgrades require the same change in every component, and describe the mitigation mentioned in the section.
- Testability and fast feedback. Explain how testability supports fast flow by making it easy and quick for developers and the deployment pipeline to verify that a change is releasable.
- Measurable testability scenarios. Describe how the section expresses testability requirements through scenarios covering ease of writing automated tests, fast local tests during editing and before a push, and timely pipeline feedback after a push.
- Three dimensions of testability. Explain that an architecture supports high testability when it enables automated tests that run quickly and can run on a developer’s machine without a separate test environment.
- Automated tests for releasability. Explain why developers need to write and run automated tests during development and after pushing a change, rather than rely on manual testing to determine releasability.
- Small loosely coupled elements. Explain how small elements with loose design-time coupling and stable APIs make automated tests easier to maintain.
- Limited non-deterministic code. Explain why non-determinism makes automated verification harder and how the section recommends containing it.
- Test-friendly programming techniques. Distinguish how dependency injection and functional-style programming each simplify testing.
- Affected-project test selection. Explain why validating a change should run tests for affected build projects rather than every project, and describe how incremental builds select those projects.
- Stable API project dependencies. Explain how loose build-time coupling reduces retesting, using the distinction between a subdomain's API and implementation build projects.
- Localized changes through cohesion. Explain how loose design-time coupling and high cohesion reduce the number of test suites needed to validate a change.
- Faster in-memory unit tests. Describe how dependency injection and functional-style programming can replace some slow infrastructure-dependent integration tests with fast unit tests.
- Component-local test pipelines. Explain why loosely coupled components with separate deployment pipelines can speed up testing when a change is local to one component.
- Value of local testing. Explain why developers should usually test locally rather than use a separate remote test environment.
- Independent component testing. Explain how a multi-component architecture can make local testing practical for a large application, using the Order Service example.
- Deployability and fast flow. Explain that deployability describes how quickly, easily, and reliably a pipeline-tested component can be deployed to production, and why frequent changes make it important to fast flow.
- Fast production deployment. Describe the successful deployability scenario: after a pipeline finishes testing a component, it deploys the update to production within five minutes without violating SLAs.
- Detection and rollback scenarios. Distinguish the two failure scenarios: a deployed update fails to start because of configuration, or its REST endpoints show unacceptably high latency. Describe how the problem is detected and the deployment rolled back without violating SLAs.
- Automated and reliable deployments. Explain why the deployment pipeline should deploy tested components automatically and how deployments can avoid disrupting work already in progress.
- Short deployment lead time. Trace the main deployment steps and explain which delays make deployments a bottleneck for fast flow.
- Build once configure at runtime. Describe how one packaged component can be deployed through multiple environments without rebuilding it.
- Progressive release exposure. Distinguish deploying a new version from releasing traffic to it, and describe how a canary release limits the impact of a production bug.
- Verification and rapid rollback. Explain how to judge whether a deployment works and how to reverse it quickly if it fails.
- Observability and fast flow. Explain what observability means here and why it matters for fast flow: it helps teams understand application and user behavior, use production feedback, detect and roll back failed deployments, and diagnose and fix production issues.
- Metrics for deployment decisions. Trace how metrics emitted during deployment reach the deployment mechanism and inform whether a deployment succeeds or is rolled back.
- Telemetry for developer understanding. Describe how telemetry reaches developers and what it helps them understand.
- Telemetry and observable behavior. Explain how collecting and analyzing telemetry helps reveal application behavior and performance, including reliability issues and how users use features.
- Instrumentation and operations collaboration. Describe how instrumentation in components and infrastructure services work together to provide observability, and distinguish developers' and operations' responsibilities.
- Component boundaries and telemetry detail. Explain why a multi-component architecture can make telemetry more informative about individual subdomains.
What it builds on
- Fast flow: continuous change and feedback (chapter 1) · Introduces fast flow as continuous change and feedback.
- The software delivery feedback loop (chapter 1) · Introduces the software delivery feedback loop.
- Who defines an application’s architecture? (chapter 3) · The architecture advice process for making design decisions.
- Benefits of loose design-time coupling (chapter 4) · The benefits of loose design-time coupling.
- Design-time coupling and cohesion (chapter 4) · Design-time coupling and cohesion.
- Design-time coupling (chapter 4) · The discussion of design-time coupling provides context for loosely coupled elements.
- About build-time coupling in Gradle projects (chapter 4) · The introduction to build-time coupling in Gradle projects.
- A project should only be build-time coupled to stable projects (chapter 4) · The principle that a project should depend only on stable projects.
Section by section
Introduction
The introduction frames fast flow as an architectural concern and identifies five quality attributes for assessing it.
- Fast flow architectural requirements: Explain that fast flow means continuously delivering small changes and getting rapid feedback, and that it requires loose design-time coupling and a rapid deployment pipeline.
Why it matters: These requirements explain why the chapter evaluates architecture in terms of fast flow. - Five fast flow quality attributes: Describe a quality attribute as a measurable, desirable application property defined through specific scenarios, and distinguish the five attributes by what each makes easier: changing the application, evolving its technology stack, verifying releasability, deploying changes, or understanding runtime and user behavior.
Why it matters: The five attributes provide the vocabulary for discussing how an architecture supports fast flow.
Key terms: fast flow, design-time coupling, rapid deployment pipeline, quality attribute, modifiability, evolvability, testability, deployability, observability
5.1 Introduction to architectural requirements for fast flow
This section describes the iterative workflow for completing a flow item, the range of changes a flow item may require, and why every workflow step must be fast and straightforward.
- Nested development feedback loops: Trace the outer change-deploy-analyze loop and the developer’s nested edit-test-analyze loop, including where feedback comes from.
Why it matters: The two loops show where a team spends time and receives feedback while completing a flow item. - Range of flow item changes: Describe how a flow item can range from a small local code change to changes spanning architecture, technology, or deployment configuration.
Why it matters: Fast flow must accommodate more than quick edits to application code. - Speed across workflow steps: Explain why fast flow requires every step of the development workflow to be fast and straightforward.
Why it matters: The workflow provides a way to assess where architecture must reduce effort and delay.
Key terms: flow item, change-deploy-analyze loop, edit-test-analyze loop, deployment pipeline, architectural modifications, technology stack, fast flow, workflow
5.1.1 Step #1: Making a change
This section explains how architecture affects the speed of making design decisions and implementing changes, the two parts of the change step.
- Decision scope and speed: Explain why the number of people affected by a design decision affects how quickly it can be made, and why localized changes help.
Why it matters: Keeping decisions local reduces the coordination needed to make a change. - Change enabling quality attributes: Describe the architectural properties that speed design decisions and identify the roles of modifiability and evolvability.
Why it matters: These attributes name what the architecture must provide to make design decisions quickly. - Rapid implementation feedback loop: Trace how developers implement a change through the edit-test-analyze loop and explain what lets them iterate rapidly.
Why it matters: Fast local testing and timely feedback keep implementation from slowing the change step.
Key terms: design decisions, architecture advice process, localized changes, modifiability, evolvability, edit-test-analyze loop, testability, trunk
5.1.2 Step #2: deploy changes
This section explains how a fast deployment pipeline delivers prompt feedback on changes and what developers do with its results.
- Fast per-change deployment pipeline: Trace how a pushed change moves through the deployment pipeline and explain why short lead time and processing changes individually matter for prompt feedback.
Why it matters: A fast pipeline lets developers get feedback on individual changes without waiting for a batch. - Deployment quality attributes: Distinguish the two quality attributes associated with a fast deployment pipeline and describe deployability at the level defined here.
Why it matters: These attributes name the architectural qualities needed to make deployment feedback fast. - Pipeline outcome follow-up: Describe what developers analyze after a deployment pipeline failure or success.
Why it matters: Deployment produces feedback that developers must act on, whether the pipeline fails or succeeds.
Key terms: deployment pipeline, lead time, wait time, processing time, batching, testability, deployability, results, behavior of the application and its users
5.1.3 Step #3: analyze feedback from production and end-users
This subsection explains why analyzing a deployed change requires accessible production feedback and identifies observability as the relevant quality attribute.
- Production feedback and observability: Explain why developers need feedback after deployment and how observability helps them understand an application’s behavior in production.
Why it matters: Accessible production feedback lets developers assess what happened after a change was deployed.
Key terms: observability, telemetry, logs, metrics, distributed traces
5.2 Modifiability: ease and speed of change
This section introduces high modifiability as an architectural requirement for fast flow.
- Modifiability and fast flow: Explain why fast flow requires an application architecture with high modifiability.
Why it matters: This connects the goal of rapid delivery to a requirement the application’s architecture must support.
Key terms: fast flow, modifiability
5.2.1 Quality attribute scenarios for modifiability
This section uses two Orders team scenarios to show how localized changes, team autonomy, and perceived ease of change express modifiability requirements for fast flow.
- Localized and autonomous changes: Explain why modifiability for fast flow calls for teams to make changes without regularly involving other teams, to keep changes within a component where possible, and to find their subdomains straightforward to change.
Why it matters: These requirements describe what an architecture must make practical for teams delivering changes quickly. - Orders team modifiability scenarios: Distinguish the Orders team's localized business-rule change from its UI feature change that also affects an API, including why the team can usually avoid coordinating with other teams and how its experience is reported.
Why it matters: The examples make clear that team autonomy is a usual outcome, not an absolute rule against collaboration.
Key terms: modifiability, fast flow, component, subdomains, Orders team, Order Management subdomain, Order Service's API, Discount Service, backwards compatible, surveys
5.2.2 Modifiability requires loose design-time coupling and high cohesion
Loose design-time coupling and high cohesion improve modifiability by keeping changes small and reducing coordination across teams and components.
- Localized Changes and Team Autonomy: Explain why loose design-time coupling and high cohesion make changes more local, and how loose coupling between teams’ subdomains lets teams work mostly independently.
Why it matters: Changes are faster to make when a team can make decisions and edit its own code without coordinating with other teams. - Single Component Change Localization: Explain how loose design-time coupling between components reduces the likelihood that a change spans components and why that saves effort.
Why it matters: Keeping a change within one component avoids the extra work of coordinating changes and deployments across components. - Small Subdomain Change Scope: Describe how loose design-time coupling and cohesion can confine a change to a small part of a subdomain, making it easier for a developer to understand and implement.
Why it matters: A small change scope makes it easier to find the relevant code and modify it.
Key terms: modifiability, loose design-time coupling, high cohesion, team autonomy, subdomain, component, multi-component changes, cohesion, classes
5.3 Evolvability: ease and speed of changing the technology stack
This section introduces evolvability as the ease of changing an application’s technology stack and explains why those changes are necessary even when requirements stay the same.
- Meaning of evolvability: Explain that evolvability describes how easy it is to change an application’s technology stack, and distinguish such changes from ordinary modifications by their potentially widespread impact.
Why it matters: The breadth of a stack upgrade makes its ease of change an architectural concern in its own right. - Need for stack updates: Explain why an application may need technology-stack updates even if its requirements do not change, including the possibility of an urgent library upgrade.
Why it matters: A team must be able to make technology changes that it did not plan as feature work.
Key terms: evolvability, technology stack, modifiability, cross-cutting change, unplanned changes, vulnerability
5.3.1 About technology stacks
Defines what belongs to an application’s technology stack, distinguishes component-specific from shared stacks, and explains why technology relationships constrain version choices.
- Technology stack contents and versions: Describe the categories of technology in an application’s stack and explain why a stack is a set of specific technology versions.
Why it matters: It gives you a precise way to discuss what must work together when an application’s technologies change. - Private and shared technology stacks: Distinguish a component’s private technology stack from technologies shared across components, and explain how components can use different technologies or versions.
Why it matters: A technology choice or upgrade need not affect every component in the same way, though some choices are shared. - Technology relationships and compatibility: Explain the requires, excludes, and provides relationships between technologies or versions, and why those relationships make assembling a compatible stack difficult.
Why it matters: These constraints explain why selecting or upgrading one technology can force other stack decisions.
Key terms: technology stack, application technologies, infrastructure services, development tools, deployment environment, technology versions, private technology stack, application-level technology stacks, shared parts, component
5.3.2 Technology evolves
5.3.3 Evolvability quality attribute scenarios
This section uses a difficult monolith upgrade and concrete scenarios to show what high evolvability requires of technology-stack changes.
- Cross-team upgrade bottleneck: Explain why a framework upgrade needed by one team can be difficult in a shared monolith, even when the feature’s code changes are confined to one subdomain.
Why it matters: A locally needed technology change can become an organization-wide decision. - Independent and urgent upgrades: Describe the scenarios in which a team upgrades a subdomain’s library without coordinating with other teams and an organization rapidly upgrades a vulnerable library; explain why the latter also depends on quick testing and deployment.
Why it matters: Teams need freedom to make routine changes, while security fixes cannot wait on a slow release process. - Incremental technology migrations: Describe how a widely used library upgrade or a database migration can proceed one team and subdomain at a time rather than as one application-wide task.
Why it matters: Breaking a large migration into team-sized changes avoids requiring every team to move at once. - Low-cost realistic technology experiments: Explain what the Rust evaluation scenario requires a team to do and what makes the experiment low cost yet realistic.
Why it matters: A deployable subdomain experiment lets a team assess a new technology without making it an expensive application-wide commitment.
Key terms: monolith, Order Management subdomain, framework upgrade, evolvability, technology stack element, testability, deployability, incrementally upgrade, subdomain, minimal coordination
5.3.4 Architecting for high evolvability
This section explains how a multi-component architecture can make technology changes easier to scope, stage, and test, while making some shared upgrades more repetitive.
- Component-local upgrades and vulnerabilities: Explain why technology stack elements private to a component can be upgraded by that component’s team, and why a vulnerable library used by only some components requires upgrades only to those components. Distinguish these cases from technology shared across components, which requires coordination.
Why it matters: The scope of a dependency determines how many components and teams must participate in changing it. - Incremental application-wide upgrades: Explain how a multi-component architecture lets teams split even an application-wide framework or JVM upgrade into component-specific tasks rather than upgrading the whole application at once.
Why it matters: Staging a large upgrade by component lets teams continue other work alongside it. - Contained technology experiments: Describe how a team can evaluate a candidate technology by implementing a subdomain with it and deploying that work as a separate service, without committing the entire application to the experiment.
Why it matters: An isolated, deployable trial lets a team assess a technology without making the whole application depend on the outcome. - Repeated shared upgrades: Explain the trade-off that some upgrades require the same change in every component, and describe the mitigation mentioned in the section.
Why it matters: Component-by-component flexibility has a maintenance cost when the same upgrade is needed everywhere.
Key terms: multi-component architecture, technology stack elements, vulnerability, component-specific upgrade tasks, flow items, subdomain, candidate technology, separate service, build logic, plumbing code
5.4 Testability: ease and speed of verifying releasability
Introduces testability as the ease and speed of verifying that a change is releasable, and explains why it matters to fast flow.
- Testability and fast feedback: Explain how testability supports fast flow by making it easy and quick for developers and the deployment pipeline to verify that a change is releasable.
Why it matters: Faster verification helps developers get feedback on changes without slowing the flow of delivery. - Fast pipeline quality attributes: State that a fast deployment pipeline relies on both testability and deployability.
Why it matters: It places verification within the broader requirement for a fast deployment pipeline.
Key terms: testability, releasable, edit-test-analyze loop, deployment pipeline, fast flow, deployability
5.4.1 Quality attribute scenarios
The section expresses testability as application-specific, measurable scenarios for writing tests easily and getting fast feedback at each stage of a change.
- Measurable testability scenarios: Describe how the section expresses testability requirements through scenarios covering ease of writing automated tests, fast local tests during editing and before a push, and timely pipeline feedback after a push.
Why it matters: These scenarios give teams concrete ways to judge whether testing supports fast feedback throughout a change.
Key terms: quality attribute scenarios, testability, edit-test-analyze loop, pre-commit tests, deployment pipeline
5.4.2 Architecting for high testability
High testability depends on an architecture that supports automated, fast-running tests that developers can run locally.
- Three dimensions of testability: Explain that an architecture supports high testability when it enables automated tests that run quickly and can run on a developer’s machine without a separate test environment.
Why it matters: These dimensions explain what an architecture must make possible for testing to support fast feedback.
Key terms: testability, automatable, fast running tests, running tests locally
5.4.3 Testable using automated tests
This section explains why fast flow depends on automated tests and how software design can make those tests easier to write and run.
- Automated tests for releasability: Explain why developers need to write and run automated tests during development and after pushing a change, rather than rely on manual testing to determine releasability.
Why it matters: Automated tests give developers timely evidence about whether a change can be released. - Small loosely coupled elements: Explain how small elements with loose design-time coupling and stable APIs make automated tests easier to maintain.
Why it matters: The structure of an application affects how much work its tests require. - Limited non-deterministic code: Explain why non-determinism makes automated verification harder and how the section recommends containing it.
Why it matters: Containing unpredictable behavior helps keep most automated test results trustworthy. - Test-friendly programming techniques: Distinguish how dependency injection and functional-style programming each simplify testing.
Why it matters: These techniques offer different ways to reduce the setup needed for automated tests.
Key terms: automated tests, manual testing, releasability, fast flow, small, loosely design-time coupled elements, stable APIs, tests, API clients, non-determinism, deterministic code
5.4.4 Testable using fast running tests
This section explains how incremental builds and architectural design keep change-validation tests fast by limiting which projects need retesting and shortening the tests themselves.
- Affected-project test selection: Explain why validating a change should run tests for affected build projects rather than every project, and describe how incremental builds select those projects.
Why it matters: Testing only what a change affects can make validation much faster than rerunning a large application's entire test suite. - Stable API project dependencies: Explain how loose build-time coupling reduces retesting, using the distinction between a subdomain's API and implementation build projects.
Why it matters: Where build dependencies point determines how widely an implementation change spreads retesting. - Localized changes through cohesion: Explain how loose design-time coupling and high cohesion reduce the number of test suites needed to validate a change.
Why it matters: Keeping changes local reduces validation work even before considering how fast any individual test runs. - Faster in-memory unit tests: Describe how dependency injection and functional-style programming can replace some slow infrastructure-dependent integration tests with fast unit tests.
Why it matters: Fast validation depends on shortening individual test suites as well as running fewer of them. - Component-local test pipelines: Explain why loosely coupled components with separate deployment pipelines can speed up testing when a change is local to one component.
Why it matters: Component boundaries can limit both the tests a change triggers and the time spent waiting to validate it.
Key terms: affected projects, incremental builds, incremental task execution, test classpath, loose build-time coupling, API build project, implementation build project, loose design-time coupling, high cohesion, localized changes
5.4.5 Running testing locally
This section explains why local testing supports fast development, how architecture makes it practical for large applications, and when remote testing is necessary.
- Value of local testing: Explain why developers should usually test locally rather than use a separate remote test environment.
Why it matters: Where tests run affects how quickly developers can get feedback on a change. - Resource limits of large applications: Describe why running all of a large application locally may be impractical and how more powerful development resources address, but do not necessarily solve, that problem.
Why it matters: Hardware capacity can constrain local testing, but buying more capacity has limits. - Independent component testing: Explain how a multi-component architecture can make local testing practical for a large application, using the Order Service example.
Why it matters: Separating components is useful for local development only when developers can work without running the whole application. - Necessary remote testing exceptions: Describe when a remote test environment may be necessary and how component separation can limit its use.
Why it matters: A requirement for some remote tests need not force every component into a remote testing workflow.
Key terms: local testing, remote testing environment, edit-test-analyze loop, infrastructure services, Cloud Development Environment, multi-component architecture, component, test doubles, Order Service, webhook endpoints
5.5 Deployability: ease, speed and reliability of deployments
Defines deployability’s role in fast flow and illustrates how a deployment mechanism moves a validated update into production.
- Deployability and fast flow: Explain that deployability describes how quickly, easily, and reliably a pipeline-tested component can be deployed to production, and why frequent changes make it important to fast flow.
Why it matters: Fast flow depends not just on validating changes, but on getting them into production quickly and reliably. - Deployment mechanism and workflow: Describe the deployment mechanism’s role after pipeline validation and trace the Kubernetes example from publishing an image through updating its reference to rolling out new instances.
Why it matters: The example makes clear what it means for a validated change to become a production deployment.
Key terms: deployability, testability, deployment pipeline, fast flow, deployment mechanism, container image, container registry, Kubernetes YAML, rolling update
5.5.1 Deployability quality attribute scenarios
This section defines deployability through scenarios for a fast, disruption-free deployment and for rollback when a deployed update fails.
- Fast production deployment: Describe the successful deployability scenario: after a pipeline finishes testing a component, it deploys the update to production within five minutes without violating SLAs.
Why it matters: This scenario makes deployment speed and continuity concrete requirements. - Detection and rollback scenarios: Distinguish the two failure scenarios: a deployed update fails to start because of configuration, or its REST endpoints show unacceptably high latency. Describe how the problem is detected and the deployment rolled back without violating SLAs.
Why it matters: A deployment must be recoverable when an update fails at startup or performs badly after reaching production.
Key terms: deployment pipeline, deployability, SLAs, configuration problem, startup failure, REST endpoints, latency, rolled back
5.5.2 Architecting for high deployability
The section explains how deployment architecture can make releases fast, reliable, independently manageable, verifiable, and reversible.
- Automated and reliable deployments: Explain why the deployment pipeline should deploy tested components automatically and how deployments can avoid disrupting work already in progress.
Why it matters: Frequent releases need to be routine without creating avoidable errors or interrupting users. - Short deployment lead time: Trace the main deployment steps and explain which delays make deployments a bottleneck for fast flow.
Why it matters: A slow rollout can hold up changes even after testing is complete. - Independent team deployments: Explain how a multi-component architecture lets teams deploy without coordinating with other teams and can prevent a single pipeline from becoming a bottleneck.
Why it matters: Independent pipelines reduce both cross-team coordination and waiting for other changes. - Build once configure at runtime: Describe how one packaged component can be deployed through multiple environments without rebuilding it.
Why it matters: A single build can be promoted between environments while receiving the settings appropriate to each one. - Progressive release exposure: Distinguish deploying a new version from releasing traffic to it, and describe how a canary release limits the impact of a production bug.
Why it matters: A new version can be tried in production without exposing every user to a possible bug at once. - Verification and rapid rollback: Explain how to judge whether a deployment works and how to reverse it quickly if it fails.
Why it matters: Fast detection and reversal keep a bad deployment from affecting users longer than necessary.
Key terms: automated deployments, deployment pipeline, reliable, connection draining, deployment time, lead time, rollout, provisioning, startup time, multi-component architecture
5.6 Observability: ease of understanding an application’s runtime behavior
Defines observability as a fast-flow quality attribute and explains why understanding runtime behavior matters.
- Observability and fast flow: Explain what observability means here and why it matters for fast flow: it helps teams understand application and user behavior, use production feedback, detect and roll back failed deployments, and diagnose and fix production issues.
Why it matters: Understanding what happens in production helps teams respond quickly and keep changes flowing.
Key terms: observability, fast flow, feedback from production and users
5.6.1 Quality attribute scenarios for observability
This section describes two observability requirements: metrics for deployment decisions and telemetry for developers to understand application and user behavior.
- Metrics for deployment decisions: Trace how metrics emitted during deployment reach the deployment mechanism and inform whether a deployment succeeds or is rolled back.
Why it matters: Observability gives the deployment mechanism evidence for deciding whether to keep a deployment. - Telemetry for developer understanding: Describe how telemetry reaches developers and what it helps them understand.
Why it matters: Telemetry makes application and end-user behavior visible to the teams responsible for the components.
Key terms: metrics, error rate, latency, observability infrastructure, deployment mechanism, rolled back, telemetry, developers, components, users
5.6.2 Architecting for observability
This section explains how telemetry practices and component boundaries improve an application's observability.
- Telemetry and observable behavior: Explain how collecting and analyzing telemetry helps reveal application behavior and performance, including reliability issues and how users use features.
Why it matters: Telemetry is useful when it helps you understand both what the application is doing and how people use it. - Instrumentation and operations collaboration: Describe how instrumentation in components and infrastructure services work together to provide observability, and distinguish developers' and operations' responsibilities.
Why it matters: Useful telemetry requires both instrumented application components and services that can process what they emit. - Component boundaries and telemetry detail: Explain why a multi-component architecture can make telemetry more informative about individual subdomains.
Why it matters: Component boundaries affect whether measurements expose a specific subdomain's behavior or hide it in an aggregate.
Key terms: observability, telemetry, logs, metrics, traces, observability patterns, instrumentation code, infrastructure services, domain-specific metrics, component instance
5.7 Summary
Where this is used later
- (chapter intro) (chapter 6) · The five quality attributes used to express architectural requirements for fast flow.
- Comparing two definitions of the microservice architecture (chapter 7) · Introduces the architectural requirements for fast flow.
- The monolithic architecture and the quality attributes for fast flow (chapter 6) · Provides a criterion for evaluating a monolith’s quality attributes for fast flow.
- A technology-oriented architectural style for the domain architecture (chapter 6) · Relates loose design-time coupling to modifiability.
- Domain module design (chapter 6) · Connects domain module design to the ease of understanding and changing a subdomain.
- Supports multiple technology stacks (chapter 7) · The concept of a technology stack.
- Enables fast, sustainable flow (chapter 7) · Architecting for high evolvability.
- Overview of the microservice architecture pattern language (chapter 7) · testability as an architectural requirement for fast flow
Concepts explained in this chapter
- component architectureA component architecture organizes an application into software components and defines their structural relationships.
- evolvabilityEvolvability is the ability of an application or its technology stack to be changed, upgraded, or experimented with rapidly and independently.
- telemetryTelemetry is operational data generated by a running system, including logs, metrics, and traces.
- test doubleA test double is a substitute component that simulates the behavior of a real collaborator or dependency during testing.
- vulnerabilityA vulnerability is a weakness in software or its dependencies that can be exploited to compromise security or cause harm.
- rollbackA rollback is a recovery operation that restores data or system state to a previously valid state by discarding or reversing changes.
- technology stack upgradeA technology stack upgrade is a change that updates the programming languages, libraries, frameworks, platforms, or tools used by an application component.
- modifiabilityModifiability is a system's ability to support changes in its behavior or other qualities after initial deployment.
- 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.
- observabilityObservability is the degree to which an application's runtime behavior and user-impacting effects can be understood from its externally visible outputs.
- canary deploymentA canary release runs a new software version alongside the current version and initially routes only a small share of traffic to it.
- component per teamComponent per team is an organizational and architectural arrangement in which each team owns a component and its deployment process.
- deployment automationDeployment of software by an automated system without manual execution of deployment steps.
- external configurationExternal configuration is a pattern in which runtime configuration is supplied from outside a software component instead of being hard-wired into it.
- fast deploymentA fast deployment is a deployment process that moves a tested software change into production in a short amount of time.
- progressive deliveryA progressive deployment gradually exposes a newly deployed software version to increasing portions of production traffic.
- loose couplingAn architectural property in which software elements have limited dependencies on one another, allowing them to change more independently.
- dependency injectionDependency injection is a technique in which an object's or component's dependencies are supplied from outside rather than constructed internally.
- design for testabilityDesign for testability is the practice of structuring software so that its behavior and properties can be verified efficiently through automated tests.
- functional programmingFunctional-style programming is a programming approach that emphasizes functions with limited side effects and minimizes dependencies on mutable state.
- testabilityTestability is the degree to which a system's behavior and properties can be verified through testing.
- deployabilityDeployability is the degree to which software can be reliably deployed to a target environment with manageable effort and risk.
- evolvability quality attributeA quality attribute describing how easily and quickly an application can evolve its technology stack.
- experimentationThe practice of evaluating a technology through controlled trials that approximate the application's real operational needs.
- technology lifecycleThe progression of a technology from introduction through wider adoption to decline or discontinuation.
- quality attribute scenarioA quality attribute scenario is a structured specification of an event, its source, the resulting response, the response measure, the environment, and the affected system artifact.
- 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.
- incremental buildAn incremental build is a build process that recompiles, retests, or repackages only software elements affected by changes.
- unit testA unit test verifies a small, isolated unit of software behavior, typically executing quickly within a local development environment.
- technology stackThe combination of programming languages, runtimes, frameworks, libraries, and supporting technologies used to build and run an application or service.
- transitive dependencyA dependency introduced indirectly through another dependency rather than declared directly by the application.
- componentA modular structural unit of a software system that groups related implementation or functionality.
- fast flowThe rapid movement of software changes from development into production, supported by rapid feedback.
- quality attributeA measurable or testable property indicating how well a system satisfies stakeholder needs beyond its basic functionality.
- software architectureThe structures of a software system, including its elements, their relationships, and their properties.
- cohesionCohesion is the degree to which the elements or responsibilities within a software component belong together.
- distributed tracing systemDistributed tracing is the recording and analysis of request execution across multiple distributed software components.
- log aggregationLog aggregation is the centralized collection and organization of log records from multiple application components or instances.
- observability patternA reusable architectural pattern for making an application's runtime behavior and user activity understandable from operational outputs.
- lead timeThe elapsed time required for a software change to flow through the deployment pipeline.
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.
