liveBook · Manning

Chapter 5: Architectural requirements for fast flow

What you will learn in chapter 5 of Microservices Patterns, Second Edition

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

What it builds on

Section by section

Introduction

The introduction frames fast flow as an architectural concern and identifies five quality attributes for assessing it.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

Concepts explained in this chapter

← Chapter 4: The importance of loose coupling Chapter 6: The monolithic architecture →

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.