What you will learn in Microservices Patterns, Second Edition
Designing applications for fast flow and high reliability
Chapter by chapter
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.
What you learn in chapter 1 →Chapter 2: FTGO: A case study in moving from one kind of development hell to another
The chapter introduces FTGO’s move from an outgrown monolith to microservices as a case where a suitable architectural choice still went badly wrong.
What you learn in chapter 2 →Chapter 3: Software architecture: what is it, why does it matter and who does it?
The introduction argues that understanding architecture fundamentals is necessary before deciding when and how to use microservices, then previews the chapter’s topics.
What you learn in chapter 3 →Chapter 4: The importance of loose coupling
Introduces loose coupling, defines when software elements are coupled, and explains why different forms of coupling matter to change speed and runtime behavior.
What you learn in chapter 4 →Chapter 5: Architectural requirements for fast flow
The introduction frames fast flow as an architectural concern and identifies five quality attributes for assessing it.
What you learn in chapter 5 →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.
What you learn in chapter 6 →Chapter 7: The Microservice architecture: enabling fast sustainable flow
The introduction explains when outgrowing a monolith can make migration to microservices sensible, then previews the chapter.
What you learn in chapter 7 →Chapter 8: Interprocess communication in a microservice architecture
The introduction explains why interprocess communication is central to microservices and why choosing an IPC mechanism is an architectural decision.
What you learn in chapter 8 →Chapter 9: Implementing system commands with sagas
The chapter introduces sagas as a service collaboration pattern for commands that update data across multiple services.
What you learn in chapter 9 →Chapter 10: Saga coordination mechanisms
Introduces what saga coordination must accomplish and distinguishes choreography’s event-driven control from orchestration’s dedicated orchestrator.
What you learn in chapter 10 →Chapter 11: The design of the FTGO 'Create Order saga'
Introduces the FTGO Create Order saga as a concrete application of earlier saga concepts and outlines the chapter’s design topics.
What you learn in chapter 11 →Chapter 12: Using the API Composition pattern to implement system queries
The introduction explains why queries spanning multiple services need application-level collaboration rather than database-level joins or distributed transactions.
What you learn in chapter 12 →Chapter 13: Using the CQRS pattern to implement system queries
The introduction explains why some queries need a query-specific CQRS view instead of querying data-owning services, and identifies the resulting tradeoff.
What you learn in chapter 13 →Concepts explained in this book
- microservice architectureAn architectural style that structures an application as a collection of independently deployable services aligned with business capabilities.
- monolithic architectureAn architecture in which an application is built and deployed as a single unit.
- loose couplingAn architectural property in which software elements have limited dependencies on one another, allowing them to change more independently.
- sagaA distributed transaction pattern that coordinates a sequence of local transactions and, when necessary, compensating actions across services.
- CQRSA distributed query pattern that maintains a read-only queryable replica combining data from multiple services.
- 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.
- API compositionA service collaboration pattern that invokes multiple service APIs and combines their results into a response.
- channelA communication path through which messages are sent and received.
- evolvabilityEvolvability is the ability of an application or its technology stack to be changed, upgraded, or experimented with rapidly and independently.
- saga orchestratorA saga orchestrator coordinates saga steps by invoking participants, maintaining saga state, and determining what to do based on their outcomes.
- independent deploymentA deployment arrangement in which application modules are packaged and released as independently deployable services.
- asynchronous communicationA messaging technique in which a sender continues processing without waiting for an immediate reply.
- 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.
- view databaseA view database is a data store dedicated to maintaining and serving the data required by a CQRS view’s queries.
- software architectureThe structures of a software system, including its elements, their relationships, and their properties.
- CQRS viewA query-oriented representation of application data maintained separately from the transactional model in CQRS.
- database indexA database structure that supports efficient retrieval of rows or records based on selected fields or expressions.
- component architectureA component architecture organizes an application into software components and defines their structural relationships.
- remote procedure callAn interaction style in which a client invokes an operation on a remote service through a call resembling a local method invocation.
- domain moduleA cohesive application module corresponding to a business subdomain and containing its business, interface, and infrastructure logic.
- API composerAn API composer invokes multiple service APIs and combines their results into a client response.
- compensating transactionA transaction that semantically undoes the effects of a previously committed transaction.
- handlerAn event handler is a software component that receives an event and performs the associated processing.
- choreography-based sagaLinear choreography is a saga coordination pattern in which events trigger saga participants sequentially.
- service discoveryService discovery is a mechanism that lets services find and communicate with service instances without hardcoded network locations.
- service-level objectiveA target value for a service-level indicator that expresses a desired level of reliability or performance.
- runtime couplingA strong runtime dependency in which one component's failure or unavailability prevents another from completing its operation.
- schemaA formal definition of the fields, types, and structural rules of a message or data object.
- contract testingTesting that verifies services and their clients or collaborators conform to agreed interaction contracts without requiring them to be tested together.
- view repositoryA software component that applies provider-event data to a query view, including mapping it to a schema and writing it.
- tight couplingA relationship in which software elements have substantial dependencies on one another.
- interprocess communicationInterprocess communication is the exchange of data or control between independently executing processes through mechanisms such as network calls or message passing.
- test doubleA test double is a substitute component that simulates the behavior of a real collaborator or dependency during testing.
- observabilityObservability is the degree to which an application's runtime behavior and user-impacting effects can be understood from its externally visible outputs.
- publish-subscribe patternA messaging channel that distributes each published message to subscribing consumers.
- isolationA database transaction setting that determines which effects of concurrent transactions may be observed.
- saga participantA service or component that performs one or more local transactions as part of a saga.
- interface definition languageAn interface definition language is a formal language for specifying the operations, data structures, and communication contracts exposed by software interfaces.
- modifiabilityModifiability is a system's ability to support changes in its behavior or other qualities after initial deployment.
- providerA provider service is a service that owns some of the data returned by a distributed query and exposes that data through an API.
- technology stack upgradeA technology stack upgrade is a change that updates the programming languages, libraries, frameworks, platforms, or tools used by an application component.
- 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.
- subdomainA coherent area of business responsibility within a larger domain.
- technology stackThe combination of programming languages, runtimes, frameworks, libraries, and supporting technologies used to build and run an application or service.
- circuit breaker patternA circuit breaker pattern stops calls to a failing dependency for a period and later permits test calls to determine whether it has recovered.
- contractAn interface that defines how software components interact and access one another's functionality.
- distributed operationA distributed operation is an application operation whose execution spans multiple services and requires inter-service communication.
- microservice architecture pattern languageAn organized collection of related patterns for making architectural and design decisions about microservice systems.
- idempotencyThe property of an operation that repeated application of the same input produces the correct effective outcome.
- modular monolithA modular monolith is a monolithic application organized into independently structured modules with explicit boundaries and limited coupling.
- fallbackA fallback pattern supplies a degraded but useful result when the primary operation or dependency fails.
- orchestration-based saga coordinationA saga whose steps are coordinated by a centralized orchestrator.
- design-time couplingThe degree to which software elements must be designed or changed together because of dependencies between them.
- api styleAn API style guide is an organization-wide set of conventions for designing, naming, documenting, securing, and evolving APIs.
- synchronous callSynchronous code performs operations in a sequence that waits for each operation to complete before continuing.
- command-side replicaA command-side replica is a service collaboration pattern that maintains replicated data to support distributed command processing.
- outbox patternA messaging pattern that atomically records an outgoing message alongside a business-data change in the same database transaction, then publishes the message afterward.
- componentA modular structural unit of a software system that groups related implementation or functionality.
- denormalizationDenormalized data is data stored with deliberate redundancy to make retrieval more efficient.
- quality attributeA measurable or testable property indicating how well a system satisfies stakeholder needs beyond its basic functionality.
- point-to-point communicationA point-to-point channel delivers each message to exactly one consumer among those reading from the channel.
- telemetryTelemetry is operational data generated by a running system, including logs, metrics, and traces.
- message orderingThe sequencing constraint that messages are processed in the order established by their publication or channel position.
- 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.
- cohesionCohesion is the degree to which the elements or responsibilities within a software component belong together.
- 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.
- domain eventAn event representing a business-significant state change of a domain entity or aggregate.
- finite-state machineA state machine is a computational model consisting of states and defined transitions between them in response to events or conditions.
- OpenAPI specificationA standard for describing HTTP APIs, including their operations, parameters, and schemas, in a machine-readable format.
- replication lagA delay between a change being made on one side of a replicated system and becoming visible on another.
- commandA system operation that mutates application data.
- database transactionA unit of work whose operations execute under defined consistency and completion semantics.
- rest apiAn HTTP-based application programming interface that exposes resources according to REST constraints.
- partial failureA distributed-system failure in which an invoked service is unavailable or responds with excessive latency while other components continue operating.
- service collaboration patternA recurring architectural solution for coordinating interactions and distributed operations among services.
- idempotent consumer patternA messaging pattern in which a consumer detects and discards duplicate messages so repeated delivery has the effect of processing a message once.
- infrastructure couplingInfrastructure coupling is a dependency in which services are affected by shared deployment infrastructure, infrastructure resources, or infrastructure configuration changes.
- health check endpointAn endpoint that can be invoked to determine whether a service instance is healthy and available to handle requests.
- upsertA database operation that inserts a record if it is absent and updates it otherwise.
- transaction boundaryA transaction boundary defines the scope within which operations are governed by rules for success, failure, concurrency, conflicts, and visibility.
- serviceA software component that provides a cohesive set of capabilities within an application.
- durabilityThe transaction property that preserves committed changes despite subsequent failures or restarts.
- eventA notification representing something notable that has occurred in an application.
- distributed query executionA data-retrieval operation whose required data resides across multiple services.
- 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.
- breaking changeA modification to an interface or behavior that can invalidate existing consumers or require them to change.
- 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.
- canary deploymentA canary release runs a new software version alongside the current version and initially routes only a small share of traffic to it.
- data transfer objectA data transfer object is a data structure that carries structured data across an interface without exposing domain implementation objects.
- microservices-first approachAn application-development strategy that begins by decomposing or building applications as microservices rather than first considering a monolithic design.
- resiliency patternA resiliency pattern is a design technique that limits the impact of failures, overload, or excessive latency in a distributed system.
- command messageA message requesting that a receiver invoke a specified operation with specified parameters.
- semantic lockA semantic lock is an application-level record flag or locking convention that indicates an uncommitted value may change and should be restricted or treated cautiously.
- asynchronous requestAn interaction style in which a requester sends a request and later receives a response without blocking for an immediate result.
- service boundaryA service boundary is a division that defines the responsibilities and scope of a service within a distributed application.
- retryA retry mechanism is logic that repeats a failed operation to recover from transient failures.
- queryA system operation that retrieves application data without mutating it.
- messageA message is a structured unit of data transmitted between communicating software components, potentially containing headers and a payload.
- orchestration serviceAn orchestration service is a service that executes saga orchestration by persisting saga state, making participant requests, and retrying failed executions.
- distributed monolithA distributed system whose services remain tightly coupled and therefore retain the disadvantages of a monolith.
- backward compatibilityThe property of allowing existing clients to continue interacting correctly with an API after a change.
- HTTP methodAn HTTP verb is a standardized request method indicating the intended operation on a resource.
- hypermediaHATEOAS is a REST constraint in which resource representations contain links that guide clients through available application actions.
- OpenAPI documentAn OpenAPI document is a machine-readable description of an API's endpoints, methods, parameters, representations, authentication, and metadata.
- resourceA REST resource is a representation-addressable business object or collection of business objects exposed by an API.
- RESTAn architectural style for networked systems defined by constraints on interactions between components and resources.
- REST maturity modelThe REST maturity model classifies HTTP APIs by their progression from a single endpoint toward resource orientation, HTTP verbs, and hypermedia controls.
- lead timeThe elapsed time required for a software change to flow through the deployment pipeline.
- scenarioA scenario is a description of an application's dynamic behavior across elements represented in its architectural views.
- invariantAn invariant is a condition that must remain true for application data or system state to be valid.
- 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.
- transaction managementTransaction management is the coordination of transactional operations to preserve the required consistency and completion semantics of data changes.
- view serviceA view service is a service that maintains and serves a query-oriented view of data.
- fine-grained architectureAn architecture that divides application functionality into many small components or services, often requiring numerous inter-component interactions.
- commutative updateA commutative update is an update operation designed to produce an equivalent result regardless of the order in which compatible updates execute.
- pessimistic viewA pessimistic view is a saga design technique that orders steps to reduce business risk from observing intermediate or dirty data.
- reread valueReread value is a concurrency technique that rereads a record before overwriting it and aborts when the record has changed since its earlier read.
- version fileA version file is a record of operations on a database record that allows those operations to be reordered during concurrent processing.
- architectural decisionThe process of choosing and governing the fundamental structure, relationships, and principles of a software system.
- ACIDA database transaction that provides atomicity, consistency, isolation, and durability guarantees.
- concurrencyConcurrency is the condition in which multiple operations or transactions execute during overlapping periods of time.
- 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.
- pivot transactionA saga transaction that marks the point after which the saga must complete through forward recovery or subsequent noncompensatable actions.
- system operationAn externally meaningful operation that an application performs in response to a request or workflow step.
- data inconsistencyA condition in which representations of related data differ across services or components that should agree.
- data serviceA service whose primary responsibility is providing other application services with access to data.
- consistencyConsistency is the transaction property that a committed transaction leaves the system in a valid state while preserving defined invariants and constraints.
- competing consumersCompeting consumers are multiple consumers that concurrently process messages from the same channel or consumer group.
- distributed transactionA transaction identified and coordinated across multiple participating resource managers.
- two-phase commitTwo-phase commit is a distributed transaction protocol that coordinates participants through a prepare phase and a commit or rollback phase.
- testabilityTestability is the degree to which a system's behavior and properties can be verified through testing.
- precomputationThe calculation of values in advance so they can be stored and retrieved rather than recomputed for each query.
- incremental buildAn incremental build is a build process that recompiles, retests, or repackages only software elements affected by changes.
- event contractAn event contract specifies the data and structure that an event publisher provides to its consumers.
- side-by-side APIA side-by-side API is an API implementation that supports old and new contract versions concurrently during a transition.
- deployabilityDeployability is the degree to which software can be reliably deployed to a target environment with manageable effort and risk.
- end-to-end testingAn end-to-end test exercises a complete application workflow across multiple services or system components.
- nondistributed transactionA local transaction is a transaction whose scope is restricted to the data and resources managed by one service.
- partial outcomeA partial outcome is a result that reports acceptance or intermediate progress before the complete processing outcome is known.
- don't repeat yourself principleA design principle requiring each piece of knowledge in a system to have a single, unambiguous, authoritative representation.
- iceberg principleA software design principle in which an element exposes a small API relative to the larger implementation that it hides.
- protobufProtocol Buffers is a language-neutral, platform-neutral mechanism for serializing structured data using compact binary encoding and numeric field tags.
- latencyLatency is the elapsed time between initiating an operation and receiving its result or response.
- ACDACD is a transaction model providing atomicity, consistency, and durability without isolation.
- by valueBy value is a concurrency strategy that selects transaction mechanisms according to the business risk of each request.
- pending stateA pending state is a business-entity state indicating that an operation is in progress and its result is not yet committed.
- business capabilityA distinct ability through which an organization performs or delivers a meaningful part of its business.
- adapterA software component that connects application logic to an external interface or system by translating between their interfaces.
- business logicBusiness logic consists of the rules and computations that implement an application's domain behavior.
- driven adapterAn adapter that enables application business logic to access external systems or services.
- hexagonal architectureHexagonal architecture is an architectural pattern that isolates application and domain logic from external systems through ports and adapters.
- inbound adapterAn adapter that receives external requests and invokes application business logic.
- 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.
- rollbackA rollback is a recovery operation that restores data or system state to a previously valid state by discarding or reversing changes.
- access token patternAn authentication and authorization pattern in which a gateway passes a validated bearer token containing user information to invoked services.
- communication patternA pattern category for implementing inter-process and client-to-service communication in a distributed application.
- consumer-side contract testA contract test that verifies a service client can communicate correctly with the service.
- cross-cutting concernA cross-cutting concern is an architectural concern that affects multiple services or components rather than a single service.
- deployment platformA platform that automates applying desired application and infrastructure state to a runtime environment.
- exception trackingThe collection, deduplication, alerting, and resolution tracking of application exceptions.
- GitOpsAn operational approach that manages infrastructure and applications declaratively through version-controlled Git state and automated reconciliation.
- Microservice ChassisA reusable service framework that provides common infrastructure capabilities and conventions for microservices.
- security patternA pattern category for protecting communication and services in a distributed architecture.
- service component testA test that exercises a service in isolation from other services.
- service deployment patternA pattern category for deploying and managing the many independently deployable services in a microservice application.
- service templateA reusable template that provides a standardized starting structure and infrastructure for implementing a service.
- application-level service discoveryApplication-level service discovery is service discovery implemented by application services and clients interacting with a dedicated service registry.
- client-side discoveryClient-side discovery is a service discovery pattern in which a client retrieves service instances from a registry and selects one for a request.
- platform-provided service discoveryPlatform-provided service discovery is service discovery implemented by a deployment platform rather than by application code.
- self-registrationSelf-registration is a service discovery pattern in which a service instance registers its own network location with a service registry.
- server-side discoveryServer-side discovery is a service discovery pattern in which a client sends a request to a router that discovers and selects a service instance.
- service instanceA running deployment of a service that has a network location and can handle requests.
- service registryA service registry is a database that records the network locations of service instances.
- third-party registrationThird-party registration is a service discovery pattern in which an external registrar registers service instances with a service registry.
- non-breaking changeA change that preserves the behavior or contract expected by existing API clients.
- polling publisherA messaging pattern in which a separate process periodically queries a database outbox for unsent messages and publishes them.
- transaction log tailingA messaging pattern that publishes messages derived from changes read from a database transaction log.
- retriable transactionA retriable transaction is a Saga step after the pivot transaction that is guaranteed to succeed, potentially through repeated invocation after transient failure.
- horizontal scalingA scaling technique that increases capacity by adding concurrent instances of a service or processing component.
- build viewAn architectural view describing source repositories, build projects, and the path changes take from development to production.
- 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.
- AsyncAPIAsyncAPI is a machine-readable specification for defining asynchronous messaging APIs, including channels, messages, operations, and message schemas.
- analytical queryA query that derives summary or analytical results from stored data, often across many records.
- error budgetAn error budget is the allowable amount of unreliability a service can experience while remaining within its service level objectives.
- service-level indicatorA service level indicator is a quantitative measurement of an API's or service's real-world behavior.
- fan-out choreographyA choreography arrangement in which a request or event is published to multiple participants that independently consume the data they need.
- outbox tableAn outbox table is a persistent table that stores messages to be delivered reliably as part of an application's transaction.
- data groupingThe organization of related data together in a record to match how queries retrieve it.
- semantic versioningSemantic versioning is a convention that assigns major, minor, and patch numbers to communicate the compatibility and nature of software changes.
- architectural requirementAn architecturally significant requirement is a requirement that has a substantial influence on a system's architecture.
- nonfunctional requirementA non-functional requirement specifies how well an application performs its functions or how easily it can be developed and maintained.
- dirty readA dirty read is a concurrency anomaly in which a transaction reads data written by another transaction before that write is committed.
- lost update anomalyA concurrency anomaly in which one update overwrites another update made from the same previously read data without detecting the conflict.
- compensatable stepA saga step before the pivot transaction whose effects may need to be undone by a compensating transaction.
- 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.
- consumer lagThe number of events a consumer or view has yet to process.
- atomicityAtomicity is the transaction property that all operations succeed as one unit or the transaction has no effect.
- partitionA partition is an independently ordered subdivision of a distributed message stream that supports parallel processing.
- deployment automationDeployment of software by an automated system without manual execution of deployment steps.
- 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.
- component per teamComponent per team is an organizational and architectural arrangement in which each team owns a component and its deployment process.
- external configurationExternal configuration is a pattern in which runtime configuration is supplied from outside a software component instead of being hard-wired into it.
- vulnerabilityA vulnerability is a weakness in software or its dependencies that can be exploited to compromise security or cause harm.
- one-way notificationA one-way notification is a service interaction in which a client sends a request without expecting or receiving a reply.
- domain viewA software architecture view that represents an application's business domains and the programming elements and relationships that implement them.
- API evolutionAPI evolution is the controlled modification of an API contract while managing compatibility with its existing consumers.
- business criticalityBusiness criticality is the degree to which a software capability is essential to an organization's business operations or value generation.
- patternA pattern is a reusable solution to a recurring design or architectural problem in a particular context.
- deployment viewA software architecture view describing the infrastructure on which application components run and the relationships among its elements.
- command channelA command channel is a message channel through which a participant receives command messages.
- api clientAn API client is a software component that consumes operations or messages exposed by a service API.
- client libraryA service-provided library is a client library published by a service team that encapsulates interaction with that service's API.
- code generationCode generation is the automated production of source code or related implementation artifacts from higher-level specifications.
- deserializationDeserialization is the conversion of transmitted or stored data into in-memory application objects or structures.
- handwritten DTOA handwritten DTO is a manually implemented data transfer object maintained by the client team.
- serializationSerialization is the conversion of in-memory data into a format suitable for transmission or storage.
- untyped data modelAn untyped data model represents message payloads with dynamically structured maps or dictionaries rather than statically modeled classes.
- activity diagramAn activity diagram is a workflow diagram that shows participants, activities, and the sequence or control flow between steps.
- architecturally significant scenarioAn architecturally significant scenario is a scenario that captures an application's essential behavior or imposes technical requirements that shape its architecture.
- service blueprintA service blueprint is a diagram that maps a customer journey to the service operations and supporting architectural elements that enable it.
- UML collaboration diagramA UML collaboration diagram, also called a communication diagram, shows interactions among participants using a freeform arrangement with ordering indicated separately.
- UML sequence diagramA UML sequence diagram is a diagram that shows participants and the time-ordered interactions between them.
- parallelismParallel execution runs independent saga steps concurrently rather than waiting for each step to finish before starting the next.
- saga coordination logicSaga coordination logic is the control logic that sequences saga steps, invokes participants, transfers data, and triggers compensating transactions.
- sequential processingSequential execution runs saga steps one after another, starting each step after the preceding step completes.
- timeout mechanismA timeout mechanism limits how long an operation may wait for a response before treating the wait as a failure or exceptional condition.
- command/reply-based messagingAn interaction style in which one party sends a command and another party returns a reply describing the result.
- domain event publishingA messaging technique in which a service publishes events representing significant changes to domain entities or aggregates.
- layered architectureAn architectural style that organizes software elements into layers with defined responsibilities and constrained dependencies.
- saga stateSaga state is the durable data recording a saga instance's execution position and information needed to continue it.
- reply messageA message communicating the result of processing a prior request or command message.
- more the merrier anti-patternAn anti-pattern in which services are added indiscriminately, producing an excessively fine-grained and complex architecture.
- 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.
- continuous deploymentContinuous deployment is the practice of automatically deploying every production-ready software change to production.
- fault isolationFault isolation is the ability to contain a component failure so that it does not bring down unrelated components.
- scalabilityThe capacity of a system to handle increasing workload by adding or adjusting resources while maintaining acceptable behavior.
- Resilience4jResilience4j is a Java library that provides fault-tolerance mechanisms such as circuit breakers, retries, rate limiters, and time limiters.
- publish/async responseAn interaction style in which a client publishes a request and receives responses asynchronously from interested services.
- request-response patternAn interaction style in which a client sends a request and waits for a timely response.
- countermeasureA saga countermeasure is an application-level design technique that reduces anomalies caused by the absence of isolation across saga transactions.
- unit testA unit test verifies a small, isolated unit of software behavior, typically executing quickly within a local development environment.
- event publisherAn event publisher is a component that emits integration events after a service operation or event handler has processed an input.
- integration eventAn integration event is an event exchanged between services that communicates an operation result or transports data needed by another service.
- event channelAn event channel is a named communication path that transports events published by a saga participant.
- Gradle ProjectA configuration and set of tasks that transforms source code into compiled or packaged software artifacts.
- core subdomainA core subdomain contains business logic that is unique to an organization and provides competitive advantage.
- domain-specific software development regulationA domain-specific software development regulation is a mandatory rule governing how software for a particular regulated domain must be developed and maintained.
- generic subdomainA generic subdomain contains business logic that is common across businesses and does not require organization-specific customization.
- resource requirementA resource requirement is the amount and type of computing resources needed by software to achieve its operational goals.
- security boundaryA security boundary is a controlled interface across which access to protected resources is mediated and restricted.
- security requirementA security requirement is a condition specifying how software, systems, or data must be protected against threats.
- supporting subdomainA supporting subdomain contains business logic that is common across businesses but requires organization-specific customization.
- message payload formatThe representation used to encode the data carried in a message’s payload.
- technology-oriented architectural styleA technology-oriented architectural style organizes an application primarily around technical concerns or infrastructure layers rather than business domains.
- A Pattern LanguageA structured collection of related patterns describing recurring design problems and their interrelationships within a domain.
- forcesForces are competing concerns or constraints that must be addressed when solving a problem in a particular context.
- related patternsRelated patterns are patterns whose solutions or problem relationships are explicitly connected to a given pattern.
- resulting contextA resulting context is the set of consequences produced by applying a pattern, including benefits, drawbacks, and newly introduced issues.
- software patternA software pattern is a reusable solution to a software architecture or design problem defined in terms of collaborating software elements.
- strategy patternThe Strategy pattern is an object-oriented design pattern that encapsulates interchangeable algorithms behind a common interface.
- message brokerA message broker is middleware that receives, routes, and delivers messages between communicating applications.
- messagingAn integration technique in which software components communicate by sending and receiving messages through a messaging system.
- command producer outbound adapterA command producer outbound adapter is an outbound adapter that creates and sends command messages to saga participants.
- inbound reply handler adapterAn inbound reply handler adapter is an inbound adapter that receives participant reply messages and invokes saga orchestration logic.
- saga instanceA saga instance is a runtime record representing one execution of a saga, including its request data and current state.
- continuous deliveryContinuous delivery is the practice of frequently integrating, testing, and deploying small software changes so that releases remain reliably deliverable.
- traditional architecture teamAn architecture team is a team responsible for addressing application-wide architectural concerns and supporting development teams with architectural guidance.
- bulkheadA bulkhead pattern isolates resources used by different operations or dependencies so that one failure or overload does not exhaust shared capacity.
- cachingA caching pattern stores previously obtained data so that subsequent requests can be served without accessing the original provider.
- rate limitA rate limiter pattern restricts the frequency or volume of calls made to a resource or dependency.
- time limiterA resiliency pattern that bounds how long an operation may wait for completion before it is treated as failed.
- message relayA software component that reads unpublished messages from an outbox and publishes them to a message broker.
- transaction logA time-ordered database record of committed changes made by application transactions.
- transaction log minerA software component that reads database transaction-log entries and converts relevant changes into messages.
- component viewAn architectural view that represents an application as deployable components containing subdomains.
- serialization anomalyA concurrency anomaly in which the combined outcome of interleaved transactions or sagas is not equivalent to any serial execution.
- write skewA concurrency anomaly in which concurrent operations read overlapping data and update disjoint data in a way that violates an invariant.
- availabilityThe degree to which a system or service is operational and accessible when required.
- snapshot eventA snapshot event carries a representation of current state so a consumer can initialize or rebuild its data.
- service-level agreementA service-level agreement is a documented commitment that defines expected, measurable service levels and associated obligations or consequences.
- multi-repoMulti-repo is a repository arrangement in which application services or components are maintained in separate repositories.
- single-service queryA query whose required data is contained within a single service rather than spanning multiple services.
- commit phaseThe second phase of two-phase commit in which the coordinator instructs participants to commit or roll back according to their votes.
- transaction coordinatorA component that coordinates transaction participants and directs them to commit or roll back as a unit.
- prepare phaseThe first phase of two-phase commit in which participants make changes durable, retain required locks, and vote whether they can commit.
- XAA standard distributed transaction processing model that defines coordination among transaction participants through a global transaction manager.
- 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.
- vertical sliceA vertical slice is an architectural partition that cuts through multiple layers to contain the functionality for a specific business capability.
- request/reply interactionA communication pattern in which a client sends a request and receives a reply from the recipient.
- 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.
- reactive architectureReactive design structures software around asynchronous, nonblocking abstractions that represent and compose results over time.
- structured concurrencyStructured concurrency is a concurrency model that scopes concurrent tasks within a well-defined lifetime and hierarchy.
- service queryA service API operation that retrieves data needed by a query composed across multiple services.
- architecture advice processThe architecture advice process is a decision-making practice in which a decision-maker seeks input from everyone affected by an architectural decision and from experts in its subject area.
- centralized decision-makingCentralized decision-making is an organizational arrangement in which architectural decisions are made by a central person or group rather than by the development teams.
- decentralizationDecentralized decision-making is an organizational arrangement in which architectural decisions are made within the teams that implement and are affected by them.
- Eventuate Tram Saga frameworkThe Eventuate Tram Saga framework provides infrastructure for defining and executing sagas that coordinate transactions across services.
- implicit architectureImplicit architecture is an application architecture that emerges without anyone consciously designing or governing it.
- AvroA schema-based data serialization system that supports compact encoding and schema resolution between writers and readers.
- IDL compilerAn IDL compiler transforms interface definitions into generated message classes and serialization or deserialization code.
- JSONJSON is a text-based data interchange format that represents structured data using objects, arrays, and primitive values.
- JSON SchemaJSON Schema is a declarative specification for describing and validating the structure and constraints of JSON data.
- schema registryA service that stores, retrieves, and versions data schemas and may validate compatibility between versions.
- schema resolutionSchema resolution is the process of reconciling a serialized message's writer schema with a consumer's reader schema.
- tagged fieldA tagged field is a serialized message field identified by a numeric identifier rather than only by position or name.
- xmlXML is a text-based markup language and data interchange format that represents structured information with elements and attributes.
- X-aaS interaction styleThe X-aaS interaction style is a team interaction in which one team consumes another team’s work as a service.
- experimentationThe practice of evaluating a technology through controlled trials that approximate the application's real operational needs.
- evolvability quality attributeA quality attribute describing how easily and quickly an application can evolve its technology stack.
- technology lifecycleThe progression of a technology from introduction through wider adoption to decline or discontinuation.
- Apache KafkaApache Kafka is a distributed event-streaming platform for publishing, storing, and consuming streams of records.
- asynchronous architectureAn asynchronous architecture is an architecture in which communicating components can continue processing without waiting for immediate responses.
- at-least-once deliveryA message-delivery guarantee in which every message is delivered one or more times, permitting redelivery after failures.
- persistenceMessage persistence is the storage of messages so they survive broker crashes or restarts.
- delivery guaranteeA delivery guarantee specifies the conditions under which a messaging system delivers messages to consumers.
- topicA topic is a broker-managed message destination representing a stream or publication target for messages.
- KinesisAn AWS service for collecting, processing, and analyzing streaming data records in scalable ordered streams.
- queueA FIFO queue is a queue that guarantees first-in, first-out message delivery.
- RabbitMQRabbitMQ is an open-source message broker that implements messaging protocols and routes messages between producers and consumers.
- messages and channels modelA messaging model that represents communication in terms of messages exchanged through abstract channels independently of the underlying messaging system.
- transitive dependencyA dependency introduced indirectly through another dependency rather than declared directly by the application.
- distributed commandA command whose data updates span multiple services.
- nonrepeatable readA fuzzy read is a concurrency anomaly in which repeated reads of the same data return different values because another transaction modifies it between reads.
- couplingCoupling is a dependency between software elements in which changes, failures, or shared resources in one element can affect another.
- pass-through design-time couplingA dependency caused when intermediate services must carry data that their own business logic does not use.
- Gradle subprojectA Gradle subproject is an independently configurable project within a larger Gradle build, with its own source code, dependencies, and build tasks.
- development-time quality attributeA development-time characteristic is a property of software development affected by how software elements are designed, built, or changed.
- runtime quality attributeA runtime quality attribute is a measurable property of an application during operation, such as availability, performance, or security.
- asynchronous programmingAn asynchronous implementation performs an operation's work independently of the caller after the invocation returns.
- performancePerformance is the responsiveness and resource efficiency with which a software system performs its operations.
- design patternA design pattern is a reusable solution to a recurring software design problem, often expressed through collaborating object-oriented elements.
- proxyA provider proxy is an intermediary component that invokes a provider service and applies behavior such as resiliency controls or fallback handling.
- api composition serviceAn API composition service is a service that contains the API composer responsible for implementing a system query.
- GradleAn open-source build automation system that models builds as tasks and supports dependency management and incremental execution.
- clientA service client is a software component that invokes one or more service APIs on behalf of a user interface or application.
- message formatThe defined representation and structure of a message exchanged between software components.
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.
