Chapter 1: Microservices: an architecture for fast flow
The introduction frames faster, more reliable, lower-risk software delivery as the reason to consider microservices, while stressing that they are appropriate only for some applications.
After this chapter you will be able to
- Sustainable software delivery improvement. Explain why the author considers microservices: businesses need faster, more reliable, lower-risk software delivery, and sustained improvement requires changing how software is developed rather than simply working longer hours.
- Conditional fit for fast flow. Explain that accelerating delivery calls for fast flow and an architecture that enables it, but that microservices enable fast flow for some applications, not all.
- Fast flow and business agility. Explain what fast flow means and why businesses need IT to deliver software this way.
- Software delivery feedback loop. Trace how a feature moves from development into production and how feedback from users and the production environment informs further development. Explain how the interval between releases affects the speed of learning.
- Uncertain user needs. Explain why uncertainty about what users need makes early, frequent feedback and continued experimentation important.
- Early technical decision validation. Explain why releasing early and frequently matters when applications use evolving or unfamiliar technologies.
- Continuous change and feedback. Explain that fast flow means delivering changes very frequently, ideally many times a day, while receiving continuous feedback that helps an organization learn about users and technologies and run experiments.
- Four DORA delivery metrics. Describe the four DORA metrics and what each measures: lead time, deployment frequency, change failure rate, and failed deployment recovery time.
- Speed alongside delivery reliability. Explain why the section rejects the assumption that reliable delivery requires moving slowly, citing smaller, more frequent changes and the comparison between elite and low performers.
- Fast flow success triangle. Explain why fast flow requires a combination of development process, organizational structure, and architecture, rather than any one of them alone.
- DevOps ways of working. Describe DevOps as an organization-wide way of delivering software quickly and reliably, and state its three ways.
- Team Topologies team roles. Describe why Team Topologies emphasizes small, long-lived teams and distinguish stream-aligned teams from the three team types that assist them.
- Architecture’s role in fast flow. Explain why an application’s architecture must enable an organization practicing DevOps and structured using Team Topologies to deliver software quickly and reliably.
- Loose coupling and team autonomy. Explain how loose design-time coupling lets a team change its part of an application without regularly requiring another team to change code, and contrast this with tight coupling.
- Automated deployment pipeline. Describe what happens after a change is pushed or merged: an automated pipeline compiles, tests, and deploys it. Explain why this pipeline must be fast for a short feedback loop.
- Monoliths and fast flow. Explain what makes an application monolithic and why that architecture can still support fast flow.
- Growth and team autonomy. Explain why some changes in a growing monolith reduce team autonomy even when most modules are loosely coupled.
- Shared pipeline bottlenecks. Trace how application and organization growth can slow a monolith's deployment pipeline and weaken fast feedback.
- Monoliths and fast flow. Explain why a monolithic architecture, despite its simplicity, can obstruct fast flow when an application and organization are large, and why microservices may then be a better choice.
- Services and distributed requests. Describe a microservice application as two or more deployable services implementing slices of business functionality. Explain that some requests stay within one service while others require services to collaborate.
- Loose design-time service coupling. Explain what loose design-time coupling means for changes to services and how it affects collaboration between their teams.
- Independent service deployment. Distinguish a service being a deployable unit from being independently deployable, and describe the deployment pipeline this section requires.
- Autonomy of service teams. Explain how loosely design-time coupled services let teams make changes with less coordination and less interference from other teams.
- Fast service deployment pipelines. Explain why a service's dedicated deployment pipeline has low lead time, and how local testing can provide feedback sooner.
- Multiple technology stacks. Explain how different services can use different technology stacks and why that helps teams choose suitable technologies, upgrade incrementally, and experiment.
- Separate deployment by characteristics. Explain why modules with different characteristics may be packaged as separate services, using the section’s availability example.
- Distributed operation complexity. Explain why an operation spanning services is harder to design than one within a monolith, using createOrder() as an example.
- Distributed monolith risk. Describe what makes services a distributed monolith and why API changes become difficult in that situation.
- Disciplined service boundary design. Justify why microservice boundaries and the decision to add a service require deliberate trade-offs rather than making services as small or numerous as possible.
- Fast flow organizational prerequisites. Explain why adopting microservices alone is unlikely to deliver fast flow without changes to how an organization works.
- Independent deployment testing barrier. Explain how insisting on application-wide end-to-end tests before each service deployment undermines independent deployability.
- Architecture choice by fit. Explain why microservices should not be the automatic choice: a monolith can work well, especially for a small application, and the right architecture is the one whose benefits outweigh its drawbacks for that application.
- Unstable boundaries and APIs. Explain why starting with microservices can produce a distributed monolith even when microservices otherwise seem suitable.
- Root cause of slow delivery. Explain why slower development, less frequent deployments, or more coordination do not by themselves justify moving a monolith to microservices. Describe the changes to try before deciding that the monolithic architecture is preventing fast flow.
- Incremental migration over rewriting. Justify migrating functionality incrementally rather than replacing the monolith with a new microservices application in one big-bang rewrite. Describe what the section says can be moved or built as services.
Section by section
Introduction
The introduction frames faster, more reliable, lower-risk software delivery as the reason to consider microservices, while stressing that they are appropriate only for some applications.
- Sustainable software delivery improvement: Explain why the author considers microservices: businesses need faster, more reliable, lower-risk software delivery, and sustained improvement requires changing how software is developed rather than simply working longer hours.
Why it matters: It keeps the discussion focused on the delivery problem microservices might help solve. - Conditional fit for fast flow: Explain that accelerating delivery calls for fast flow and an architecture that enables it, but that microservices enable fast flow for some applications, not all.
Why it matters: It prevents treating microservices as the automatic answer whenever faster delivery is needed.
Key terms: microservice architecture, software delivery, fast flow
1.1 The need for fast flow
Defines fast flow and explains why business agility and dependence on software require smaller, more frequent releases with rapid feedback.
- Fast flow and business agility: Explain what fast flow means and why businesses need IT to deliver software this way.
Why it matters: It connects the way IT delivers changes to a business’s need to adapt and learn quickly.
Key terms: fast flow, small changes, feedback
1.1.1 The software delivery feedback loop
This section explains the software delivery feedback loop and why frequent releases are needed to learn from users and validate technical decisions.
- Software delivery feedback loop: Trace how a feature moves from development into production and how feedback from users and the production environment informs further development. Explain how the interval between releases affects the speed of learning.
Why it matters: Release frequency determines how quickly a team can check its assumptions about both features and design. - Uncertain user needs: Explain why uncertainty about what users need makes early, frequent feedback and continued experimentation important.
Why it matters: Early feedback reduces the time spent pursuing features that do not help users. - Early technical decision validation: Explain why releasing early and frequently matters when applications use evolving or unfamiliar technologies.
Why it matters: Checking technical decisions early can prevent mistakes from spreading through an architecture.
Key terms: feedback loop, production, release, fast feedback, volatile, uncertain, complex and ambiguous (VUCA), experiment, technology landscape, design decisions
1.1.2 Fast flow: continuous change and feedback
This section defines fast flow, shows how DORA metrics quantify software delivery performance, and explains its reported links to reliability, developer experience, and business success.
- Continuous change and feedback: Explain that fast flow means delivering changes very frequently, ideally many times a day, while receiving continuous feedback that helps an organization learn about users and technologies and run experiments.
Why it matters: Fast flow is about learning from frequent releases, not merely releasing quickly. - Four DORA delivery metrics: Describe the four DORA metrics and what each measures: lead time, deployment frequency, change failure rate, and failed deployment recovery time.
Why it matters: These measures make a seemingly fuzzy idea of delivery performance observable. - Speed alongside delivery reliability: Explain why the section rejects the assumption that reliable delivery requires moving slowly, citing smaller, more frequent changes and the comparison between elite and low performers.
Why it matters: Frequent releases need not come at the expense of production reliability. - Developer and business outcomes: Describe the reported developer-experience benefits of fast flow and the relationship the cited research finds between software delivery performance and organizational performance.
Why it matters: The section connects delivery practices to both developers’ working lives and business results.
Key terms: fast flow, feedback, experiments, DORA metrics, lead time, deployment frequency, change failure rate, failed deployment recovery time, elite performers, smaller changes
1.1.3 The fast flow success triangle = DevOps + Team Topologies + Architecture
The section explains how DevOps, Team Topologies, and enabling architecture work together to support fast flow.
- Fast flow success triangle: Explain why fast flow requires a combination of development process, organizational structure, and architecture, rather than any one of them alone.
Why it matters: It frames fast flow as a joint process, organization, and architecture challenge. - DevOps ways of working: Describe DevOps as an organization-wide way of delivering software quickly and reliably, and state its three ways.
Why it matters: DevOps supplies the process side of fast flow, including both delivery and learning from production. - Smaller batches and fewer handoffs: Explain how small, frequent changes and fewer hand-offs between teams support fast flow.
Why it matters: These practices make the section’s idea of fast flow concrete. - Team Topologies team roles: Describe why Team Topologies emphasizes small, long-lived teams and distinguish stream-aligned teams from the three team types that assist them.
Why it matters: End-to-end ownership helps teams move work forward without repeatedly handing it off. - Team interaction styles: Distinguish the three Team Topologies interaction styles and explain which is usual and when the others are used.
Why it matters: The interaction styles show how teams can receive help without making constant hand-offs their default.
Key terms: fast flow success triangle, DevOps, Team Topologies, architecture, three ways, first way, second way, third way, reduce batch sizes, continuous delivery
1.2 Architectural requirements for fast flow
The section explains that architecture supports fast flow by enabling DevOps and Team Topologies, then previews the architectural requirements discussed next.
- Architecture’s role in fast flow: Explain why an application’s architecture must enable an organization practicing DevOps and structured using Team Topologies to deliver software quickly and reliably.
Why it matters: It connects architectural choices to the way teams work and deliver software.
Key terms: fast flow, DevOps, Team Topologies, architecture
1.2.1 Architectural requirements for fast flow
The section explains why fast flow depends on architecture that lets teams change their code independently and move those changes rapidly through deployment.
- Architecture for engineering needs: Explain why architecture must serve the engineering organization as well as end users. Describe how architectural decisions affect the ease of future development and fast flow.
Why it matters: It explains why delivery speed is an architectural concern. - Loose coupling and team autonomy: Explain how loose design-time coupling lets a team change its part of an application without regularly requiring another team to change code, and contrast this with tight coupling.
Why it matters: Independent changes reduce coordination, waiting, and hand-offs between teams. - Automated deployment pipeline: Describe what happens after a change is pushed or merged: an automated pipeline compiles, tests, and deploys it. Explain why this pipeline must be fast for a short feedback loop.
Why it matters: Fast code changes cannot produce fast feedback if delivery to production is slow. - Deployment lead time components: Explain that pipeline lead time consists of queue wait time plus processing time, and describe why both can grow in a large application developed by large teams.
Why it matters: It distinguishes delays caused by a queue from delays caused by the pipeline's own work.
Key terms: architecture, engineering organization, fast flow, loose design-time coupling, team autonomy, stream-aligned team, automated deployment pipeline, feedback loop, push, merge
1.2.2 The Monolithic architecture can enable fast flow
A monolith can enable fast flow, but growth can make cross-team changes harder and turn its shared deployment pipeline into a bottleneck.
- Monoliths and fast flow: Explain what makes an application monolithic and why that architecture can still support fast flow.
Why it matters: It prevents treating microservices as the automatic choice whenever fast flow is the goal. - Growth and team autonomy: Explain why some changes in a growing monolith reduce team autonomy even when most modules are loosely coupled.
Why it matters: It identifies a limit on independent team progress that good module boundaries do not always remove. - Shared pipeline bottlenecks: Trace how application and organization growth can slow a monolith's deployment pipeline and weaken fast feedback.
Why it matters: It explains how a single pipeline can cease to support fast flow as both the application and its organization scale.
Key terms: monolithic application, single codebase, single deployable unit, single deployment pipeline, fast flow, team autonomy, loosely design-time coupled, breaking changes, deployment pipeline, reduce batch sizes
1.3 A brief introduction to the microservice architecture
This section explains why a large application and organization may outgrow a monolithic architecture as a way to achieve fast flow.
- Monoliths and fast flow: Explain why a monolithic architecture, despite its simplicity, can obstruct fast flow when an application and organization are large, and why microservices may then be a better choice.
Why it matters: It frames microservices as a response to specific delivery problems rather than a default replacement for monoliths.
Key terms: monolithic architecture, fast flow, deployment pipeline, microservice architecture
1.3.1 The microservice architecture: a definition
Defines the microservice architecture through its service structure, loose design-time coupling, and independent deployability, while correcting the idea that it requires many tiny services.
- Microservices as an architectural style: Explain that the microservice architecture is an architectural style: it specifies how an application is structured, rather than prescribing a particular technology.
Why it matters: This frames microservices as a choice about application structure. - Services and distributed requests: Describe a microservice application as two or more deployable services implementing slices of business functionality. Explain that some requests stay within one service while others require services to collaborate.
Why it matters: It explains both what the services contain and why serving a request can involve more than one of them. - Service size is not defining: Explain why microservices need not be numerous or tiny, and describe the section’s rule of thumb for deciding whether a service should exist.
Why it matters: It prevents service count or small size from becoming a goal in itself. - Loose design-time service coupling: Explain what loose design-time coupling means for changes to services and how it affects collaboration between their teams.
Why it matters: It connects service boundaries to teams’ ability to make changes with limited coordination. - Independent service deployment: Distinguish a service being a deployable unit from being independently deployable, and describe the deployment pipeline this section requires.
Why it matters: It shows why being separately packaged is not enough to make service changes quick to release.
Key terms: architectural style, microservice architecture, service, deployable unit, business capabilities, subdomains, distributed architecture, lots of little services, tangible problem, excessive complexity
1.3.2 The microservice architecture is a fast flow architecture
This section explains how loosely coupled services and fast, dedicated deployment pipelines enable fast flow in large, complex applications.
- Autonomy of service teams: Explain how loosely design-time coupled services let teams make changes with less coordination and less interference from other teams.
Why it matters: Team autonomy is one of the two reasons this architecture can support fast flow at a large scale. - Fast service deployment pipelines: Explain why a service's dedicated deployment pipeline has low lead time, and how local testing can provide feedback sooner.
Why it matters: Less time testing and waiting for a pipeline helps developers deliver changes and receive feedback faster.
Key terms: team autonomy, loosely design-time coupled services, technology stack, separate code base, dedicated deployment pipeline, lead time, processing time, utilization, feedback
1.3.3 Other benefits of the microservice architecture
This section explains how microservices support multiple technology stacks and allow modules with different characteristics to be deployed separately.
- Multiple technology stacks: Explain how different services can use different technology stacks and why that helps teams choose suitable technologies, upgrade incrementally, and experiment.
Why it matters: Service-by-service technology choices make it easier to keep an application’s stack current over its lifetime. - Separate deployment by characteristics: Explain why modules with different characteristics may be packaged as separate services, using the section’s availability example.
Why it matters: Separating unlike modules lets an application treat critical functionality differently from the rest.
Key terms: multiple technology stacks, services, incrementally upgrade, application modules, separate services, high availability infrastructure, architectural properties
1.3.4 No such thing as a silver bullet: the drawbacks of microservices
This section explains why microservices are not a silver bullet: distributed operations, service coupling, design discipline, organizational practices, and deployment habits can all undermine their benefits.
- Distributed operation complexity: Explain why an operation spanning services is harder to design than one within a monolith, using createOrder() as an example.
Why it matters: Splitting an operation across services introduces failure and transaction concerns that a monolithic design may not have. - Distributed monolith risk: Describe what makes services a distributed monolith and why API changes become difficult in that situation.
Why it matters: Separate deployments provide little freedom when services still have to change together. - Disciplined service boundary design: Justify why microservice boundaries and the decision to add a service require deliberate trade-offs rather than making services as small or numerous as possible.
Why it matters: More, smaller services can make an architecture slower and harder to maintain rather than improving it. - Fast flow organizational prerequisites: Explain why adopting microservices alone is unlikely to deliver fast flow without changes to how an organization works.
Why it matters: Changing the architecture without changing organizational practices may leave the promised delivery benefits unrealized. - Independent deployment testing barrier: Explain how insisting on application-wide end-to-end tests before each service deployment undermines independent deployability.
Why it matters: A shared testing gate can erase the speed advantage of deploying services independently.
Key terms: distributed operations, process boundaries, transaction boundaries, runtime coupling, eventual consistency, distributed monolith, design-time coupled, breaking change, service boundaries, loosely design-time coupled
1.4 When to use the microservice architecture
This section explains why choosing between a monolith and microservices depends on the application, whether it is new or already a monolith.
- Architecture choice by fit: Explain why microservices should not be the automatic choice: a monolith can work well, especially for a small application, and the right architecture is the one whose benefits outweigh its drawbacks for that application.
Why it matters: This keeps the architecture decision grounded in the needs of the application. - Contexts for architecture decisions: Distinguish the two situations in which this choice arises: building a new application and deciding whether an existing monolith has outgrown its architecture. State that either situation calls for careful analysis before choosing microservices.
Why it matters: It helps you recognize when to evaluate microservices without treating the situation itself as the answer.
Key terms: monolithic architecture, microservice architecture, requirements, benefits, drawbacks, brand-new application, monolithic application
1.4.1 Building an application from scratch: typically a monolith-first approach
Recommends starting a new application as a monolith in most cases, while explaining when microservices may be justified and why starting with them can be risky.
- Unstable boundaries and APIs: Explain why starting with microservices can produce a distributed monolith even when microservices otherwise seem suitable.
Why it matters: Starting with a monolith leaves room to discover service boundaries before committing to them. - Exceptions to monolith first: Describe the circumstances in which starting with a small microservice architecture might make sense.
Why it matters: The monolith-first recommendation is a default, not an absolute rule.
Key terms: distributed monolith, stable APIs, loosely design-time coupled, boundaries, monolith-first approach, mixture of technologies, simple microservice architecture, segregating modules
1.4.2 Refactoring a monolith to the microservice architecture
This section explains how to decide whether a slowing monolith needs microservices and, if it does, why to migrate incrementally rather than rewrite it all at once.
- Root cause of slow delivery: Explain why slower development, less frequent deployments, or more coordination do not by themselves justify moving a monolith to microservices. Describe the changes to try before deciding that the monolithic architecture is preventing fast flow.
Why it matters: Diagnosing the cause first can avoid an unnecessary and risky migration. - Incremental migration over rewriting: Justify migrating functionality incrementally rather than replacing the monolith with a new microservices application in one big-bang rewrite. Describe what the section says can be moved or built as services.
Why it matters: Early delivery and feedback reduce the risk of committing to a replacement that takes a long time to prove useful.
Key terms: fast flow, monolithic architecture, DevOps, Team Topologies, automated deployment pipeline, loosely design-time coupled modules, big bang rewrite, Strangler Fig pattern, incrementally migrates
1.5 Summary
Where this is used later
- Introduction to architectural requirements for fast flow (chapter 5) · Introduces the software delivery feedback loop.
- (chapter intro) (chapter 5) · Introduces fast flow as continuous change and feedback.
- Services <⇒ teams (chapter 7) · Revisits the relationship between services and teams.
- Benefits of loose design-time coupling (chapter 4) · Develops the benefits of loose design-time coupling.
- Modifiability requires loose design-time coupling and high cohesion (chapter 5) · Connects loose design-time coupling to modifiability.
- Step #2: deploy changes (chapter 5) · Examines the deployment step in the flow of a change.
- Deployability: ease, speed and reliability of deployments (chapter 5) · Develops deployability as an architectural requirement.
- Benefits of the monolithic architecture (chapter 6) · Provides the starting point for assessing the benefits of a monolithic architecture.
Concepts explained in this chapter
- microservice architectureAn architectural style that structures an application as a collection of independently deployable services aligned with business capabilities.
- deployment pipelineAn automated sequence that takes a software change through building, testing, and deployment.
- fast flowThe rapid movement of software changes from development into production, supported by rapid feedback.
- fast flow success triangleThe fast flow success triangle is a model relating DevOps, Team Topologies, and enabling architecture as the three elements required for fast flow.
- independent deploymentA deployment arrangement in which application modules are packaged and released as independently deployable services.
- 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.
- end-to-end testingAn end-to-end test exercises a complete application workflow across multiple services or system components.
- monolithic architectureAn architecture in which an application is built and deployed as a single unit.
- lead timeThe elapsed time required for a software change to flow through the deployment pipeline.
- software architectureThe structures of a software system, including its elements, their relationships, and their properties.
- DevOpsA set of practices and cultural principles that integrates software development and operations to improve the flow and reliability of software delivery.
- team topologiesTeam Topologies is an organizational design framework for structuring teams and their interactions to optimize software delivery.
- stream-aligned teamA stream-aligned team is a long-lived team responsible for an end-to-end stream of work from requirements to production software.
- distributed monolithA distributed system whose services remain tightly coupled and therefore retain the disadvantages of a monolith.
- serviceA software component that provides a cohesive set of capabilities within an application.
- distributed operationA distributed operation is an application operation whose execution spans multiple services and requires inter-service communication.
- eventual consistencyA consistency model in which a multi-service operation is completed through separate transactions whose effects converge over time rather than immediately satisfying a single ACID transaction.
- more the merrier anti-patternAn anti-pattern in which services are added indiscriminately, producing an excessively fine-grained and complex architecture.
- runtime couplingA strong runtime dependency in which one component's failure or unavailability prevents another from completing its operation.
- service boundaryA service boundary is a division that defines the responsibilities and scope of a service within a distributed application.
- continuous deliveryContinuous delivery is the practice of frequently integrating, testing, and deploying small software changes so that releases remain reliably deliverable.
- three waysThe three ways are the DevOps principles of fast flow from development to production, fast feedback from production to development, and continual experimentation and learning.
- architectural styleAn architectural style is a set of structural principles that defines the permissible components, connectors, and composition constraints for a family of software systems.
- business capabilityA distinct ability through which an organization performs or delivers a meaningful part of its business.
- loose couplingAn architectural property in which software elements have limited dependencies on one another, allowing them to change more independently.
- technology stackThe combination of programming languages, runtimes, frameworks, libraries, and supporting technologies used to build and run an application or service.
- modular monolithA modular monolith is a monolithic application organized into independently structured modules with explicit boundaries and limited coupling.
- X-aaS interaction styleThe X-aaS interaction style is a team interaction in which one team consumes another team’s work as a service.
- design-time couplingThe degree to which software elements must be designed or changed together because of dependencies between them.
- transaction boundaryA transaction boundary defines the scope within which operations are governed by rules for success, failure, concurrency, conflicts, and visibility.
- tight couplingA relationship in which software elements have substantial dependencies on one another.
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.
