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.
After this chapter you will be able to
- Architecture fundamentals before microservices. Explain why the chapter calls for a foundation in software architecture before deciding when and how to use microservices.
- Black box application behavior. Explain how a black box view describes an application through its externally visible system operations and events. Distinguish commands, which change data, from queries, which retrieve it.
- System event publication. Explain what an application event represents, including how a command's success or failure can produce one, and describe how events can reach interested parties.
- Operations and architectural boundaries. Explain why system operations influence service decomposition and how they can be used to describe an architecture's dynamic behavior.
- Architecture as parts and relationships. Explain that software architecture describes the structures needed to reason about an application, especially its decomposition into software elements and the relationships between them.
- Importance of application decomposition. Explain the two reasons decomposition matters here: it affects how teams divide work and knowledge, and the interactions between elements determine runtime behavior.
- Architecture and quality attributes. Explain why the section treats quality attributes as a precise way to describe what architecture must achieve.
- Quality attribute scenario parts. Describe the six parts of a quality attribute scenario and how its response measure helps determine whether the architecture satisfies the attribute.
- Static and scenario views. Explain how an N+1 view model describes architecture through multiple static views and a scenario view.
- Author’s four static views. Describe what the domain, component, deployment, and build views each show in the author’s 4+1 model.
- Domain View and Subdomains. Explain that the domain view organizes developers’ programming-language elements and their relationships into subdomains, each representing a slice of business functionality owned by a small team.
- Subdomain Collaboration in Operations. Trace how one subdomain initially handles a system operation and may use other subdomains, as Order Management does when handling createOrder().
- Business Logic and Adapters. Describe the subdomain as a hexagon with business logic at its core and distinguish inbound adapters, which invoke that logic, from outbound adapters, which make requests on its behalf.
- Component View and Units. Explain that the component view shows how subdomains are organized into components, and describe a component as a language- and technology-specific executable or deployable unit.
- Subdomain Grouping Choices. Describe the choice between putting all subdomains in one component and distributing them among multiple components, using an FTGO grouping as an example.
- Cross-Component Collaboration. Explain why operations spanning subdomains in different components require collaboration, and describe the role of component APIs in that collaboration.
- Deployment view elements. Explain what the deployment view represents and how components relate to the infrastructure on which they run.
- Quality driven deployment choices. Explain how quality needs affect deployment design, using the section’s simple AWS example and its limitations.
- Build view and deployment path. Trace how repositories, build projects, and deployment pipelines move code from a developer’s laptop to production. Describe what triggers a pipeline and what happens before it deploys updated components.
- Incremental build feedback speed. Explain how incremental builds speed a deployment pipeline and why a cloud-based pipeline may need a build cache.
- Pipeline structure and feedback. Distinguish the single-pipeline monolithic build view from the separate-pipeline-per-service approach, and explain their implications for lead time and feedback.
- Scenarios as behavioral view. Explain why architecture needs scenarios in addition to structural views, and distinguish scenarios about application behavior from those about delivering changes.
- Significant scenarios and participants. Describe what domain, component, and deployment scenarios trace, how their participants vary by view, and why some user story scenarios deserve particular attention.
- Change flow activity diagrams. Describe what repository and deployment pipeline scenarios show and how an activity diagram can reveal opportunities to improve a pipeline.
- Architectural style as constraint. Explain how an architectural style defines a pattern of structural organization by specifying which components and connectors may be used and how they may be combined. Describe how styles help define architectural views and why one application may use more than one style.
- Layer responsibilities and dependencies. Explain how layered architecture assigns responsibilities to layers and restricts which layers may depend on which others.
- Business logic dependency direction. Explain why the depicted dependency from business logic to persistence can be misleading, including its testing implication and the interface-based direction described here.
- Business logic at the center. Describe hexagonal architecture as a way to organize an application's logical view around its business logic, rather than around presentation and persistence tiers. Explain that adapters depend on the business logic, not the reverse.
- Inbound and outbound connections. Trace how an outside request reaches business logic through an inbound adapter and port, and how business logic reaches an external system through an outbound port and adapter. Distinguish ports, which define operations, from adapters, which handle the interaction.
- Architecture as an artifact. Distinguish an application’s architecture from architecting: architecture is the artifact, and architecting is the process that creates it.
- Architecture as accumulated decisions. Explain how architectural design decisions create and change an application’s architecture over time.
- Benefits of decision traceability. Justify recording architectural decisions in terms of avoiding over-engineering and preserving rationale.
- Team-level architectural decisions. Explain why embedding architects in teams or having team members make architectural decisions is preferable to fully centralized decision-making.
- Architecture advice process. Describe who may make a decision under the architecture advice process, whose advice they must seek, and how that advice addresses the challenge of decentralized decisions.
- Two levels of microservice architecture. Distinguish decisions about individual services from decisions about the whole application, and describe how responsibility for the latter can differ by application size.
- Evolution from a working architecture. Explain why the application should start with the simplest architecture that works and evolve as it grows. Describe how this means making architectural design decisions when problems actually need solving.
What it builds on
- What went wrong with their microservice architecture (chapter 2) · Provides the FTGO microservice mistakes cited as a caution.
Section by section
Introduction
The introduction argues that understanding architecture fundamentals is necessary before deciding when and how to use microservices, then previews the chapter’s topics.
- Architecture fundamentals before microservices: Explain why the chapter calls for a foundation in software architecture before deciding when and how to use microservices.
Why it matters: It explains why the book pauses to establish architecture fundamentals before returning to microservices.
Key terms: software architecture, architecture fundamentals, microservice architecture, FTGO organization
3.1 What is software architecture and why does it matter?
Introduces the questions of what software architecture is and why it matters, before turning to an outside view of an application.
3.1.1 An application as a black box
This section describes an application from the outside, in terms of the system operations it exposes and the events it publishes.
- Black box application behavior: Explain how a black box view describes an application through its externally visible system operations and events. Distinguish commands, which change data, from queries, which retrieve it.
Why it matters: This gives you a way to describe what an application does before examining its internal architecture. - System operation invocation paths: Describe how users, other applications, external events, and the passing of time can cause a system operation to run, without tying the operation itself to a particular technology.
Why it matters: Separating an operation from its trigger or implementation technology makes its behavior easier to reason about. - System event publication: Explain what an application event represents, including how a command's success or failure can produce one, and describe how events can reach interested parties.
Why it matters: Events are part of an application's externally visible behavior, not just a detail of how it processes commands. - Operations and architectural boundaries: Explain why system operations influence service decomposition and how they can be used to describe an architecture's dynamic behavior.
Why it matters: Thinking about whole operations exposes a cost of placing parts of one behavior in different services.
Key terms: black box, system operation, command, query, event, REST API, messaging technology, passing of time, system command, OrderCreated
3.1.2 Software architecture: a way to reason about your application
The section defines software architecture as a way to reason about an application's parts and relationships, then explains why that decomposition matters.
- Architecture as parts and relationships: Explain that software architecture describes the structures needed to reason about an application, especially its decomposition into software elements and the relationships between them.
Why it matters: This definition gives you a way to discuss an application's design beyond treating it as a black box. - Importance of application decomposition: Explain the two reasons decomposition matters here: it affects how teams divide work and knowledge, and the interactions between elements determine runtime behavior.
Why it matters: Decomposition has consequences for both development work and the running application.
Key terms: software architecture, software elements, relations, decomposition, division of labor and knowledge, runtime behavior
3.1.3 Why architecture matters
The section explains why architecture matters by comparing three ways to describe the requirements it satisfies and showing how quality attribute scenarios make those requirements testable.
- Architecture and quality attributes: Explain why the section treats quality attributes as a precise way to describe what architecture must achieve.
Why it matters: This gives you a concrete way to explain what an architecture needs to accomplish. - Traditional requirements distinction: Distinguish functional requirements from non-functional requirements, including the latter’s runtime and development-time aspects.
Why it matters: Architecture must serve developers’ need to change and deploy software as well as users’ runtime needs. - Limits of requirement categories: Explain why architecturally significant requirements were proposed and why the section finds both earlier ways of categorizing requirements imperfect.
Why it matters: It explains the section’s preference for specifying testable quality attributes instead of relying on labels alone. - Quality attribute scenario parts: Describe the six parts of a quality attribute scenario and how its response measure helps determine whether the architecture satisfies the attribute.
Why it matters: A scenario turns an abstract quality goal into a requirement that can be checked. - Runtime and development scenarios: Distinguish the section’s availability and modifiability scenarios and explain how each could be tested.
Why it matters: The examples show that architecture matters both when software runs and when people change it.
Key terms: architecture, quality attribute, functional requirements, non-functional requirements, runtime behavior, development-time requirements, architecturally significant requirements, quality attribute scenario, stimulus, stimulus source
3.2 Software architecture is multidimensional
The section introduces view models for describing an application’s architecture and presents the author’s four static views plus a scenario view.
- Static and scenario views: Explain how an N+1 view model describes architecture through multiple static views and a scenario view.
Why it matters: The distinction helps you describe both an application’s structure and what happens when it runs. - Author’s four static views: Describe what the domain, component, deployment, and build views each show in the author’s 4+1 model.
Why it matters: These views give you distinct ways to discuss the architectural choices involved in a microservice application. - Original four plus one model: Distinguish the original 4+1 model’s static views from the four chosen by the author, while identifying the role of its fifth view.
Why it matters: It clarifies that 4+1 is a way of organizing views, not a fixed list of four static perspectives.
Key terms: N+1 view model, static view, elements and relations, scenario view, domain view, component view, deployment view, build view, subdomains, components
3.2.1 Domain view
The section explains how the domain view organizes an application into business-focused subdomains, how those subdomains collaborate, and how their business logic connects to the outside through adapters.
- Domain View and Subdomains: Explain that the domain view organizes developers’ programming-language elements and their relationships into subdomains, each representing a slice of business functionality owned by a small team.
Why it matters: Subdomains provide a business-oriented way to describe what the application’s code does. - Subdomain Collaboration in Operations: Trace how one subdomain initially handles a system operation and may use other subdomains, as Order Management does when handling createOrder().
Why it matters: Business responsibilities can be divided into subdomains without requiring every operation to stay within one of them. - Business Logic and Adapters: Describe the subdomain as a hexagon with business logic at its core and distinguish inbound adapters, which invoke that logic, from outbound adapters, which make requests on its behalf.
Why it matters: The distinction shows how a business-focused subdomain can still handle requests and interact with external systems.
Key terms: domain view, subdomain, packages, Whole-Part relationships, system operation, uses relationship, createOrder(), Order Management, Consumer Management, Delivery Management
3.2.2 Component view
The section explains how the component view groups subdomains into executable or deployable units and shows how those units collaborate.
- Component View and Units: Explain that the component view shows how subdomains are organized into components, and describe a component as a language- and technology-specific executable or deployable unit.
Why it matters: This distinguishes a domain subdomain from the unit in which it is packaged. - Subdomain Grouping Choices: Describe the choice between putting all subdomains in one component and distributing them among multiple components, using an FTGO grouping as an example.
Why it matters: The same set of subdomains can yield different component architectures depending on how they are packaged. - Cross-Component Collaboration: Explain why operations spanning subdomains in different components require collaboration, and describe the role of component APIs in that collaboration.
Why it matters: Splitting subdomains across components creates interactions that the architecture must account for.
Key terms: component view, subdomain, component, executable or deployable unit, component architecture, Whole-Part relationship, system operations, collaboration, API, uses relationship
3.2.3 Deployment view
This section explains how the deployment view maps application components onto infrastructure and how deployment choices reflect an application’s quality needs.
- Deployment view elements: Explain what the deployment view represents and how components relate to the infrastructure on which they run.
Why it matters: It connects an application’s logical components to what actually runs them. - Infrastructure configuration as code: Describe how deployment infrastructure is typically defined today rather than configured manually.
Why it matters: The way infrastructure is specified is part of understanding a modern deployment architecture. - Quality driven deployment choices: Explain how quality needs affect deployment design, using the section’s simple AWS example and its limitations.
Why it matters: It helps you evaluate deployment complexity against the qualities an application actually requires.
Key terms: deployment view, component instances, infrastructure elements, networking resources, infrastructure code, desired state, Terraform, CloudFormation, Kubernetes YAML manifests, system quality attributes
3.2.4 Build view
This section explains how the build view traces code from a developer’s laptop to production and how build and pipeline structure affects feedback speed.
- Build view and deployment path: Trace how repositories, build projects, and deployment pipelines move code from a developer’s laptop to production. Describe what triggers a pipeline and what happens before it deploys updated components.
Why it matters: The build view makes the route from a code change to a production deployment explicit. - Incremental build feedback speed: Explain how incremental builds speed a deployment pipeline and why a cloud-based pipeline may need a build cache.
Why it matters: Avoiding unaffected work helps the pipeline return the fast feedback needed for fast flow. - Pipeline structure and feedback: Distinguish the single-pipeline monolithic build view from the separate-pipeline-per-service approach, and explain their implications for lead time and feedback.
Why it matters: Pipeline boundaries can determine how quickly teams receive feedback and deploy changes.
Key terms: Build view, Git repositories, build projects, deployment pipelines, incremental builds, build cache, ephemeral environments, fast feedback, monolithic architecture, microservice architecture
3.2.5 +1 Scenarios
Scenarios add behavior to the four structural architecture views by showing how elements collaborate to meet requirements or how changes reach production.
- Scenarios as behavioral view: Explain why architecture needs scenarios in addition to structural views, and distinguish scenarios about application behavior from those about delivering changes.
Why it matters: Scenarios show whether an architecture’s elements actually support the behavior and delivery the application requires. - Significant scenarios and participants: Describe what domain, component, and deployment scenarios trace, how their participants vary by view, and why some user story scenarios deserve particular attention.
Why it matters: Choosing significant scenarios makes an architecture description relevant to the application’s defining requirements. - Interaction diagram tradeoffs: Distinguish sequence diagrams from collaboration diagrams as ways to show an operation’s participants and interactions.
Why it matters: The choice of diagram affects whether readers see the participants or the order of interactions most clearly. - Customer journey service blueprints: Explain how a service blueprint connects a customer journey to the architectural elements supporting it and why that helps a broader audience.
Why it matters: A blueprint makes the connection between user experience and implementation visible beyond the technical team. - Change flow activity diagrams: Describe what repository and deployment pipeline scenarios show and how an activity diagram can reveal opportunities to improve a pipeline.
Why it matters: Making the path to production visible helps identify manual work that slows delivery.
Key terms: scenarios, domain view, component view, deployment view, build view, system operation, user story scenario, architecturally significant scenarios, classes, subdomains
3.3 Overview of architectural styles
Defines an architectural style as a constrained set of components and connectors for describing a view of an application, and notes that applications typically combine styles.
- Architectural style as constraint: Explain how an architectural style defines a pattern of structural organization by specifying which components and connectors may be used and how they may be combined. Describe how styles help define architectural views and why one application may use more than one style.
Why it matters: This gives you a way to recognize what a style specifies without assuming the whole application must follow just one style.
Key terms: architectural style, components, connectors, view, constraints
3.3.1 Layered architecture
This section defines layered architecture, illustrates it with three-tier architecture, and explains where its depiction of an application’s dependencies falls short.
- Layer responsibilities and dependencies: Explain how layered architecture assigns responsibilities to layers and restricts which layers may depend on which others.
Why it matters: The dependency rule is what makes layering more than a way to group code. - Three-tier domain view: Describe the three-tier architecture as layered architecture applied to the domain view, including the responsibilities of its three layers.
Why it matters: The three tiers make the abstract idea of layers concrete. - Single-layer representation limits: Explain why depicting just one presentation layer and one persistence layer can misrepresent an application.
Why it matters: The simple three-tier picture can hide the variety of an application’s external interactions. - Business logic dependency direction: Explain why the depicted dependency from business logic to persistence can be misleading, including its testing implication and the interface-based direction described here.
Why it matters: Dependency direction affects whether the business logic can be tested without a database.
Key terms: layered architecture, strict layering, dependencies, three-tier architecture, domain view, presentation layer, business logic layer, persistence layer, repository interfaces, DAO classes
3.3.2 About the hexagonal architecture style
This section explains how hexagonal architecture organizes business logic, ports, and adapters, and why that organization is useful.
- Business logic at the center: Describe hexagonal architecture as a way to organize an application's logical view around its business logic, rather than around presentation and persistence tiers. Explain that adapters depend on the business logic, not the reverse.
Why it matters: This gives you a way to describe an application's structure without making its business logic depend on presentation or data access code. - Inbound and outbound connections: Trace how an outside request reaches business logic through an inbound adapter and port, and how business logic reaches an external system through an outbound port and adapter. Distinguish ports, which define operations, from adapters, which handle the interaction.
Why it matters: The port-and-adapter distinction makes it clear how the business logic can communicate without being tied to a particular controller, database, or remote service. - Isolation and multiple interfaces: Explain why separating business logic from adapters makes isolated testing easier and how multiple adapters can connect the same business logic to different APIs, UIs, or external systems.
Why it matters: You can test the business logic separately and describe applications that have more than one way in or out.
Key terms: hexagonal architecture, logical view, business logic, adapters, layered architectural style, port, inbound port, outbound port, inbound adapter, outbound adapter
3.4 Architecting: what is it, who does it and when?
The section distinguishes an application’s architecture from the process of architecting that creates it.
- Architecture as an artifact: Distinguish an application’s architecture from architecting: architecture is the artifact, and architecting is the process that creates it.
Why it matters: This distinction keeps the resulting architecture separate from the work of creating it.
Key terms: architecture, artifact, architecting
3.4.1 Architecture as a series of design decisions
The section presents software architecture as the cumulative result of explicit design decisions and explains what those decisions contain and why recording them is useful.
- Architecture as accumulated decisions: Explain how architectural design decisions create and change an application’s architecture over time.
Why it matters: It gives you a way to explain where an architecture came from, rather than treating it as a fixed diagram. - Parts of a design decision: Describe the information that makes up an architectural design decision and how its chosen solution can affect the architecture.
Why it matters: Recording the alternatives and reasoning makes an architectural choice more understandable than recording its outcome alone. - Benefits of decision traceability: Justify recording architectural decisions in terms of avoiding over-engineering and preserving rationale.
Why it matters: Documented decisions help teams retain the reasons for an architecture and question parts that solve no problem.
Key terms: architecture, architecting, design decisions, problem, motivation, cause, candidate solutions, trade-offs, decision, design decision
3.4.2 Who defines an application’s architecture?
This section compares who can make architectural decisions, explains why team-level decisions need an advice process, and distinguishes service-level from application-wide architecture in microservices.
- Centralized decision-making drawbacks: Explain why a separate person or group making all architectural decisions can produce poor-quality decisions, delays, and weak team buy-in, even though it may help teams stuck in indecision.
Why it matters: Who makes a decision affects its quality, speed, and acceptance. - Implicit architecture risks: Explain why having nobody consciously consider architecture is not the same as having no architecture, and describe the likely effect on a non-trivial application.
Why it matters: Avoiding explicit decisions does not avoid their architectural consequences. - Team-level architectural decisions: Explain why embedding architects in teams or having team members make architectural decisions is preferable to fully centralized decision-making.
Why it matters: Putting decisions close to the work supports faster, more practical decisions that teams will accept. - Architecture advice process: Describe who may make a decision under the architecture advice process, whose advice they must seek, and how that advice addresses the challenge of decentralized decisions.
Why it matters: Advice lets decision-making stay decentralized without ignoring affected people or wider expertise. - Two levels of microservice architecture: Distinguish decisions about individual services from decisions about the whole application, and describe how responsibility for the latter can differ by application size.
Why it matters: Decentralizing service decisions still leaves application-wide concerns that need coordinated attention.
Key terms: benevolent dictator, centralized decision-making, buy-in, implicit architecture, big ball of mud, architect in the team, architecture done by team members, decentralizing architecture decision-making, architecture advice process, people impacted
3.4.3 When to architect?
Start with the simplest working architecture, evolve it as real needs arise, and anticipate future needs only when evidence supports doing so.
- Evolution from a working architecture: Explain why the application should start with the simplest architecture that works and evolve as it grows. Describe how this means making architectural design decisions when problems actually need solving.
Why it matters: It gives you a practical rule for deciding how much architecture to design now. - Evidence for anticipatory decisions: Distinguish speculative over-engineering from addressing a future problem supported by evidence, such as predicted load from a rapidly growing user base.
Why it matters: Evidence lets you prepare for likely needs without designing for every imagined possibility.
Key terms: Gall’s Law, simplest architecture that works, architectural design decisions, over-engineering, scalability, actual evidence, wishful thinking
3.5 Summary
Where this is used later
- System commands need to be transactional (chapter 9) · Uses the idea of system commands.
- The findOrder() system query (chapter 12) · Uses the idea of system queries.
- Overview of messaging (chapter 8) · Develops messaging as a way to exchange information between services.
- Introduction to architectural requirements for fast flow (chapter 5) · Introduces architectural requirements for fast flow in terms of application qualities.
- (chapter intro) (chapter 4) · Introduces why software architecture matters.
- Quality attribute scenarios for modifiability (chapter 5) · Uses quality attribute scenarios to specify modifiability requirements.
- Deployability quality attribute scenarios (chapter 5) · Develops deployability quality attribute scenarios.
- A technology-oriented architectural style for the domain architecture (chapter 6) · Distinguishes the component, domain, and build views of architecture.
Concepts explained in this chapter
- software architectureThe structures of a software system, including its elements, their relationships, and their properties.
- architectural decisionThe process of choosing and governing the fundamental structure, relationships, and principles of a software system.
- scenarioA scenario is a description of an application's dynamic behavior across elements represented in its architectural views.
- quality attributeA measurable or testable property indicating how well a system satisfies stakeholder needs beyond its basic functionality.
- build viewAn architectural view describing source repositories, build projects, and the path changes take from development to production.
- 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.
- 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.
- component viewAn architectural view that represents an application as deployable components containing subdomains.
- domain viewA software architecture view that represents an application's business domains and the programming elements and relationships that implement them.
- system operationAn externally meaningful operation that an application performs in response to a request or workflow step.
- deployment viewA software architecture view describing the infrastructure on which application components run and the relationships among its elements.
- 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.
- 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.
- 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.
- traditional architecture teamAn architecture team is a team responsible for addressing application-wide architectural concerns and supporting development teams with architectural guidance.
- componentA modular structural unit of a software system that groups related implementation or functionality.
- 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.
- implicit architectureImplicit architecture is an application architecture that emerges without anyone consciously designing or governing it.
- subdomainA coherent area of business responsibility within a larger domain.
- commandA system operation that mutates application data.
- eventA notification representing something notable that has occurred in an application.
- queryA system operation that retrieves application data without mutating it.
- deployment pipelineAn automated sequence that takes a software change through building, testing, and deployment.
- incremental buildAn incremental build is a build process that recompiles, retests, or repackages only software elements affected by changes.
- layered architectureAn architectural style that organizes software elements into layers with defined responsibilities and constrained dependencies.
- 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.
- contractAn interface that defines how software components interact and access one another's functionality.
- microservice architectureAn architectural style that structures an application as a collection of independently deployable services aligned with business capabilities.
- 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.
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.
