Chapter 1: The Architect's Compass: It's All About Tradeoffs
This chapter introduction previews the architecture concepts, decision-making process, and case study covered later.
After this chapter you will be able to
- Everyday architectural decisions. Explain why developers make architectural decisions even without an architect title, and describe how those choices involve real-world constraints and tradeoffs.
- Three levels of architectural responsibility. Distinguish Architectural Awareness, Alignment, and Accountability, and explain why a developer can practice the first two without owning final system-wide decisions.
- Release Speed and Maintainability. Explain the payment-feature choice between shipping quickly with logic in the OrderController and delaying release to separate the payment and invoice code. Describe how business needs, deadlines, and maintainability guide that tradeoff.
- Deliberate Technical Debt. Explain technical debt as future work caused by choosing speed over long-term quality, and distinguish a planned shortcut from shortcuts that become an unexamined habit.
- Defensible Decision Reasoning. Explain what makes an architectural decision defensible and why that does not mean the decision must be perfect.
- System shape and reasons. Explain that software architecture is the system’s shape and the significant decisions behind it, rather than the appearance of its diagrams. Describe how those decisions affect building, testing, deploying, and changing the system.
- Consequential decisions and design effort. Apply the section’s test for an architectural decision: whether a choice significantly affects later building, shipping, or changing. Explain why that does not mean every line needs formal review or every small project needs deep up-front design.
- Needs Into Technical Blueprints. Explain how software architecture translates business and user needs into a blueprint through deliberate tradeoffs about structure, patterns, and component boundaries.
- Clarifying Vague Stakeholder Requests. Describe how a Clarity Engineer listens and asks why, including about unstated requirements, to turn a vague request into something concrete and solvable without over-engineering for hypothetical futures.
- Architecture as a thinking process. Explain that architecture is a repeatable pattern of thinking that turns chaotic requests into clear, defensible plans, rather than just a finished blueprint.
- Initial request scope. Describe what to clarify about a feature request at the Spark step: what the user should be able to do, where it appears in the app, and whether it changes an existing flow or adds a new one.
- Root Cause Inquiry. Explain how the architect uses the “5 Whys” before proposing a solution to move from a surface-level request to its underlying reason.
- Deadline Driven Tradeoff. Trace how questioning the favorite-button request reveals a two-week, budget-linked marketing deadline, and justify prioritizing a functional V1 over long-term scalability in that scenario.
- Separation of concerns boundaries. Explain how Separation of Concerns reduces complexity by giving each part a distinct responsibility and a boundary against unrelated work.
- Three box favorite sketch. Trace what the UI, Logic, and Data boxes each do when a user favorites an article, and explain why the sketch keeps them separate.
- Visible design tradeoffs. Explain how to move from a design sketch to options: find an important choice, brainstorm at least two realistic approaches, and compare their tradeoffs against the priorities identified earlier.
- Existing profile storage tradeoffs. Describe what is gained and risked by putting favorites directly in the existing User profile, including the possible loss of a favorite during simultaneous saves.
- Dedicated favorites storage tradeoffs. Describe how a dedicated storage area for Favorites improves scalability and separation from User profiles while taking more work and complexity to build.
- The architectural decision receipt. Explain how to record a defensible architectural decision: state what was chosen, why it fits the Inquiry step’s goals, and which tradeoffs are being accepted.
- Foundations for AI Coding Tools. Explain why AI coding assistants can accelerate work but cannot replace foundational architectural understanding. Describe how notes, documentation, and clear mental models help a developer find their way when generated code fails.
- Language-Agnostic Architectural Principles. Explain why the book uses examples in multiple languages: principles such as separation of concerns, layers, coupling, and cohesion apply whether code is written in an object-oriented or functional style.
- Background and setup requirements. State the background, mindset, and tools needed to follow the book: familiarity with one programming language, curiosity about how systems fit together, and either a standard computer setup or a free browser-based environment.
- Four points of the compass. Explain how the Architect’s Compass guides decisions without promising a perfect architecture: ask the right questions, turn ideas into plans, account for real-world constraints, and make defensible decisions.
- Architectural Decisions and Business Stakes. Explain why Friendster is introduced as evidence that architectural decisions can have major consequences, without claiming to know the decision’s details yet.
- Friendster’s consistency tradeoff. Explain why Friendster’s choice to show every friendship change instantly across the social graph made profile pages slow and harmed availability.
- Friendster’s Scaling Consequences. Explain what happened when Friendster grew from a few hundred thousand users to millions, including the effect on users and the engineering team.
- Friendster’s costly consistency tradeoff. Explain how Friendster’s pursuit of perfect consistency came at the expense of user experience, while competitors favored fast, available pages even if new connections appeared globally a few seconds later.
- Mini Defensible Decision. Apply the exercise to a technical choice: identify two realistic options, give one benefit and one cost or risk for each, then state the final choice with a one-sentence rationale.
- Deliberate Architectural Tradeoffs. Explain why architecture consists of meaningful choices and their reasons rather than just diagrams, and why those choices must weigh competing qualities, including how a system behaves under stress and evolves.
- Architectural Decision Receipt. Describe the five stages of the Architectural Thinking Process and what its decision receipt records.
Section by section
Introduction
This chapter introduction previews the architecture concepts, decision-making process, and case study covered later.
Introduction
The section reframes architecture as everyday decision-making, presents architects as guides rather than gatekeepers, and distinguishes three levels of architectural responsibility.
- Everyday architectural decisions: Explain why developers make architectural decisions even without an architect title, and describe how those choices involve real-world constraints and tradeoffs.
Why it matters: You can start thinking architecturally in the decisions you already make, rather than waiting for a new title. - Architect as team guide: Distinguish the controlling, isolated architect from the guide described in the section, including how the guide helps the team make decisions.
Why it matters: The guide model makes architectural thinking something the team can share and develop. - Three levels of architectural responsibility: Distinguish Architectural Awareness, Alignment, and Accountability, and explain why a developer can practice the first two without owning final system-wide decisions.
Why it matters: The distinction shows how to contribute to architecture now without claiming responsibility for decisions you do not own.
Key terms: software architecture, architectural decision, real-world constraints, tradeoffs, mountaineering guides, dictator model, Architectural Awareness, Architectural Alignment, Architectural Accountability, Three A's of Architecture
1.2 Welcome to the Real World
This section uses a pressured release decision to show that software architecture means weighing competing costs and explaining the choice.
- Release Speed and Maintainability: Explain the payment-feature choice between shipping quickly with logic in the OrderController and delaying release to separate the payment and invoice code. Describe how business needs, deadlines, and maintainability guide that tradeoff.
Why it matters: It helps you make architectural choices that fit the deadline without ignoring what the system will need later. - Deliberate Technical Debt: Explain technical debt as future work caused by choosing speed over long-term quality, and distinguish a planned shortcut from shortcuts that become an unexamined habit.
Why it matters: Recognizing debt lets a team take an urgent shortcut without pretending it has no future cost. - Avoiding Needless Complexity: Explain why avoiding technical debt does not justify over-engineering a simple feature, and state when the section says to apply architectural patterns.
Why it matters: It keeps a team from trading one problem—hard-to-change code—for unnecessary design complexity. - Defensible Decision Reasoning: Explain what makes an architectural decision defensible and why that does not mean the decision must be perfect.
Why it matters: Explaining why you chose an option gives teammates a way to understand and discuss it.
Key terms: Duct Tape and Hope Route, Do It Right Detour, business needs, deadlines, maintainability, technical debt, short-term compromises, unacknowledged, unmanaged debt, over-engineer, Time to Ship
1.3 What is Software Architecture?
Defines software architecture through the food-truck analogy and gives a practical test for recognizing architectural decisions without overdesigning small projects.
- System shape and reasons: Explain that software architecture is the system’s shape and the significant decisions behind it, rather than the appearance of its diagrams. Describe how those decisions affect building, testing, deploying, and changing the system.
Why it matters: This definition keeps architectural thinking focused on consequential choices, not polished diagrams. - Structure behavior and evolution: Describe how the food-truck analogy illustrates a system’s structure, its response to traffic spikes or dependency failures, and the ease or difficulty of changing it.
Why it matters: The analogy makes clear that architecture affects everyday operation as well as future changes. - Consequential decisions and design effort: Apply the section’s test for an architectural decision: whether a choice significantly affects later building, shipping, or changing. Explain why that does not mean every line needs formal review or every small project needs deep up-front design.
Why it matters: This test helps you notice important choices without turning every small task into a design exercise.
Key terms: architecture, significant decisions, Structure, Behavior, Evolution, traffic spike, dependency failure, architectural decision, architectural thinking, duct tape
1.4 Becoming a "Clarity Engineer"
This section defines software architecture as turning stakeholder needs into a technical blueprint and explains how a Clarity Engineer questions vague requests before making tradeoffs.
- Needs Into Technical Blueprints: Explain how software architecture translates business and user needs into a blueprint through deliberate tradeoffs about structure, patterns, and component boundaries.
Why it matters: The blueprint gives technical decisions a purpose beyond simply choosing a design that works today. - Clarifying Vague Stakeholder Requests: Describe how a Clarity Engineer listens and asks why, including about unstated requirements, to turn a vague request into something concrete and solvable without over-engineering for hypothetical futures.
Why it matters: A concrete understanding of the request prevents a team from confidently building the wrong thing. - Awareness And Alignment In Practice: Distinguish Architectural Awareness from Architectural Alignment in the Clarity Engineer's work.
Why it matters: The distinction connects asking good questions to making defensible design choices.
Key terms: software architecture, technical blueprint, deliberate tradeoffs, boundaries, Clarity Engineer, stakeholders, unstated requirements, future-proofing, Architectural Awareness, Architectural Alignment
1.5 The Architectural Thinking Process: From an Idea to a Blueprint
This section frames architecture as a repeatable way of turning unclear requests into defensible plans.
- Architecture as a thinking process: Explain that architecture is a repeatable pattern of thinking that turns chaotic requests into clear, defensible plans, rather than just a finished blueprint.
Why it matters: This gives you a way to approach an unclear design request before settling on a solution.
Key terms: architecture, repeatable pattern of thinking, defensible plans
1.5.1 The Scenario:
Introduces a request for an article favorite button as the scenario for the upcoming architectural thinking process.
1.5.2 Step 1: The Spark (The "What")
Step 1 identifies what the initial feature request asks for, then pauses before coding to consider why the request matters.
- Initial request scope: Describe what to clarify about a feature request at the Spark step: what the user should be able to do, where it appears in the app, and whether it changes an existing flow or adds a new one.
Why it matters: Clarifying the request gives you a starting point before considering its implications. - Pause before coding: Explain why a developer should resist coding immediately after identifying what a feature request asks for and instead ask why.
Why it matters: A small-looking change may deserve more thought than its initial description suggests.
Key terms: The Spark, the “What”, initial request, Why, architectural implications
1.5.3 Step 2: The Inquiry (The "Why")
The Inquiry step uses repeated “why” questions to uncover the real driver of a feature request so architectural priorities reflect the business need.
- Root Cause Inquiry: Explain how the architect uses the “5 Whys” before proposing a solution to move from a surface-level request to its underlying reason.
Why it matters: A feature request can hide a more important problem or constraint. - Deadline Driven Tradeoff: Trace how questioning the favorite-button request reveals a two-week, budget-linked marketing deadline, and justify prioritizing a functional V1 over long-term scalability in that scenario.
Why it matters: A defensible tradeoff serves the actual business need, not just technical ideals. - Other Quality Questions: Describe how inquiry also probes reliability and consistency, alongside identifying the top priority for the feature.
Why it matters: Asking about other qualities helps make the feature’s priorities explicit.
Key terms: The Inquiry, 5 Whys, root cause, Speed to Ship, Scalability, functional V1, tradeoff, Reliability, Consistency
1.5.4 Step 3: The Sketch (The "How")
The Sketch step uses a simple UI–Logic–Data drawing to separate responsibilities before they become tangled in code.
- Separation of concerns boundaries: Explain how Separation of Concerns reduces complexity by giving each part a distinct responsibility and a boundary against unrelated work.
Why it matters: Clear boundaries make a system less complex by keeping unrelated responsibilities apart. - Three box favorite sketch: Trace what the UI, Logic, and Data boxes each do when a user favorites an article, and explain why the sketch keeps them separate.
Why it matters: Even a quick sketch can show where each piece of the feature belongs before the code is written.
Key terms: Separation of Concerns, concern, boundaries, napkin sketch, UI (User Interface), Logic, Data, favorited, not favorited
1.5.5 Step 4: The Options (The "Tradeoff")
This section shows how to compare realistic ways to store favorites by making their tradeoffs visible against the design’s priorities.
- Visible design tradeoffs: Explain how to move from a design sketch to options: find an important choice, brainstorm at least two realistic approaches, and compare their tradeoffs against the priorities identified earlier.
Why it matters: Visible tradeoffs let others understand what a design gains and gives up. - Existing profile storage tradeoffs: Describe what is gained and risked by putting favorites directly in the existing User profile, including the possible loss of a favorite during simultaneous saves.
Why it matters: A quick implementation can carry costs that are easy to miss when judging only delivery speed. - Dedicated favorites storage tradeoffs: Describe how a dedicated storage area for Favorites improves scalability and separation from User profiles while taking more work and complexity to build.
Why it matters: The more scalable option still has delivery and complexity costs to weigh.
Key terms: Data box, options, tradeoffs, priorities, User profile, Speed to Ship, Scalability, Maintainability, race condition, dedicated storage area
1.5.6 Step 5: The Decision (The "Receipt")
The final step turns a choice into a defensible, shared decision by recording its business rationale and accepted tradeoffs.
- The architectural decision receipt: Explain how to record a defensible architectural decision: state what was chosen, why it fits the Inquiry step’s goals, and which tradeoffs are being accepted.
Why it matters: A written rationale lets others understand the choice rather than merely inherit it. - Shared rationale and future review: Explain why the documented decision should be shared with the team and how it helps when questions, problems, or changed priorities arise.
Why it matters: A shared record keeps the team aligned and makes it easier to revisit a choice when circumstances change.
Key terms: Decision, receipt, Inquiry, tradeoffs, defensible decision, rationale, alignment
1.6 The Scope of This Book and The Skills You'll Build
The section defines the book’s practical scope and warns that AI coding tools are safest to use with a foundation in how the code works.
- Foundations for AI Coding Tools: Explain why AI coding assistants can accelerate work but cannot replace foundational architectural understanding. Describe how notes, documentation, and clear mental models help a developer find their way when generated code fails.
Why it matters: Understanding the code gives you a way to diagnose problems when an AI tool cannot solve them for you.
Key terms: AI-powered coding assistants and agents, Hansel and Gretel Trap, breadcrumbs of understanding
1.6.1 What You'll Learn
This subsection previews the architectural skills and topics the book will cover, including tradeoffs, system design, and legacy code.
1.6.2 The Hands-On Journey
This section previews the book’s hands-on chapter format, including examples, AI-assisted brainstorming, and practice missions.
1.6.3 A Language-Agnostic Approach
This section explains that architectural principles apply across programming languages and that runnable examples let readers compare how different languages express the same boundaries.
- Language-Agnostic Architectural Principles: Explain why the book uses examples in multiple languages: principles such as separation of concerns, layers, coupling, and cohesion apply whether code is written in an object-oriented or functional style.
Why it matters: You can carry an architectural idea from one language or codebase to another. - Cross-Language Example Comparison: Describe how the companion repository's runnable examples help readers practice in a familiar language and compare how different ecosystems enforce the same architectural boundaries.
Why it matters: The examples let you see a shared design idea expressed in code you can run and compare.
Key terms: language-agnostic, separation of concerns, layers, coupling, cohesion, companion GitHub repository, architectural boundaries, C#, Java, Python
1.6.4 What You Need to Know (and Have)
This section identifies who the book is for and the modest background and tools needed to follow its examples.
- Background and setup requirements: State the background, mindset, and tools needed to follow the book: familiarity with one programming language, curiosity about how systems fit together, and either a standard computer setup or a free browser-based environment.
Why it matters: You can begin exploring architecture without specialized equipment or enterprise tools.
Key terms: familiarity with one programming language, curiosity, Standard Setup, free code editor, GitHub Codespaces
1.6.5 The Architect's Compass
This subsection recaps the chapter’s compass for moving from architectural awareness toward decisions aligned with real-world needs, rather than seeking a perfect architecture.
- Four points of the compass: Explain how the Architect’s Compass guides decisions without promising a perfect architecture: ask the right questions, turn ideas into plans, account for real-world constraints, and make defensible decisions.
Why it matters: It keeps architectural choices focused on the situation at hand rather than an imagined perfect design.
Key terms: Architect's Compass, Three A's of Architecture, Awareness, Alignment, Clarity Engineer, Architectural Thinking Process
1.7 The Dork Side: Friendster and the Billion-Dollar Tradeoff
Introduces Friendster’s rapid rise and eventual failure as a cautionary example of the stakes of architectural decisions.
- Architectural Decisions and Business Stakes: Explain why Friendster is introduced as evidence that architectural decisions can have major consequences, without claiming to know the decision’s details yet.
Why it matters: A technical choice can matter to a company even when its product is growing quickly.
Key terms: architectural tradeoffs, Friendster
1.7.1 The Seduction of Perfection
Friendster’s pursuit of an instantly accurate social graph made profile pages costly to render and undermined availability.
- Friendster’s consistency tradeoff: Explain why Friendster’s choice to show every friendship change instantly across the social graph made profile pages slow and harmed availability.
Why it matters: A choice that seems technically correct can make the experience worse when its cost falls on every page load.
Key terms: Consistency, Availability, social graph, database joins
1.7.2 The Agony of the Spinning Wheel
The section shows how Friendster’s architecture became painfully slow as its user base grew and diverted engineers from building new features.
- Friendster’s Scaling Consequences: Explain what happened when Friendster grew from a few hundred thousand users to millions, including the effect on users and the engineering team.
Why it matters: The example shows that an architectural choice can hurt both the user experience and a team’s ability to improve the product as demand grows.
Key terms: infrastructure weight, spinning wheels, timeout errors
1.7.3 The Aftermath and the Lesson
Friendster’s decline illustrates how optimizing for perfect consistency at the expense of speed can hurt users, while architecture alone cannot guarantee a product’s success.
- Friendster’s costly consistency tradeoff: Explain how Friendster’s pursuit of perfect consistency came at the expense of user experience, while competitors favored fast, available pages even if new connections appeared globally a few seconds later.
Why it matters: Technical excellence does not make a tradeoff good if it sacrifices the experience users value. - Limits of architectural choices: Explain why Friendster’s architecture was not the sole cause of its demise: management decisions and an unclear product vision also contributed, and sound architecture enables success without guaranteeing it.
Why it matters: It keeps an architect from treating a technical fix as a cure for every product or leadership problem.
Key terms: Availability, Performance, Consistency, user experience, management decisions, product vision, Architecture
1.8.1 Make a Mini-Defensible Decision (Time: 10 minutes)
This exercise turns a small technical choice into a defensible decision by comparing alternatives and stating a rationale.
- Mini Defensible Decision: Apply the exercise to a technical choice: identify two realistic options, give one benefit and one cost or risk for each, then state the final choice with a one-sentence rationale.
Why it matters: It gives you a simple way to explain why you chose one technical option over another.
Key terms: tradeoffs, defensible decision, pro, con, rationale
1.9 Checklist
This section offers a self-check of concepts and skills covered earlier in the chapter.
1.10 Recap
The recap ties architectural awareness, deliberate tradeoffs, and a repeatable decision process to making choices that can be explained and defended.
- Awareness and Alignment: Explain how a developer can practice Architectural Awareness through Architectural Alignment even without Architectural Accountability, and describe how asking why helps uncover unstated requirements.
Why it matters: You can contribute to sound architectural choices before you are responsible for making them. - Deliberate Architectural Tradeoffs: Explain why architecture consists of meaningful choices and their reasons rather than just diagrams, and why those choices must weigh competing qualities, including how a system behaves under stress and evolves.
Why it matters: The quality you prioritize shapes what the system can withstand and how readily it can change. - Architectural Decision Receipt: Describe the five stages of the Architectural Thinking Process and what its decision receipt records.
Why it matters: A decision receipt makes a deliberate tradeoff understandable after the choice has been made.
Key terms: Architectural Awareness, Architectural Alignment, Architectural Accountability, Clarity Engineer, tradeoff, Consistency, Availability, Architectural Thinking Process, Spark, Inquiry
Where this is used later
- The Architect’s Role: Explainer, Scribe, Boundary Keeper, and Scout (chapter 2) · The discussion of the architect's roles builds on the distinction between guiding a team and controlling its decisions.
- Constraints in Action: "Good Enough for Now" (chapter 2) · Applies constrained, good-enough-for-now choices.
- The Cost of Decoupling: Why You Might Not Want (or Need!) Hexagonal Architecture (chapter 5) · Examines the costs of adopting an architectural pattern.
- Designing for Failure & Resilience Patterns (chapter 10) · Builds on the idea that system behavior during failures is an architectural concern.
- Recap (chapter 2) · Introduces the architect’s clarity-focused role.
- Introduction (chapter 2) · Introduces the Architectural Thinking Process recapped here.
- The “-ilities”: Your Vocabulary of Quality (chapter 2) · The Inquiry step asks why the system is needed before choosing how to build it.
- Separation of Concerns (chapter 3) · Develops Separation of Concerns as a structural principle.
Concepts explained in this chapter
- tradeoffA tradeoff is a situation in which gaining a benefit requires accepting a cost, risk, or limitation elsewhere.
- software architectureSoftware architecture comprises the significant structural and behavioral decisions that shape how a software system is built, deployed, and changed.
- architectural alignmentArchitectural alignment is the practice of keeping implementation decisions consistent with a system's architectural goals and constraints.
- architectural awarenessArchitectural awareness is recognition and understanding of the forces, priorities, and consequences that shape software architecture.
- defensible decisionA defensible decision is a technical choice supported by an explicit rationale that accounts for relevant benefits, costs, risks, and alternatives.
- three a's of architectureA framework distinguishing architectural awareness, alignment, and accountability as responsibilities in architectural work.
- accountabilityArchitectural accountability is responsibility for making and owning system-wide architectural decisions.
- time-to-marketTime to market is the elapsed time required to deliver a product or feature to its intended users or market.
- software architectA person responsible for guiding the structural and system-wide design of software.
- technical debtTechnical debt is the future cost of short-term software design or implementation compromises made in favor of speed over quality and maintainability.
- clarity engineerA Clarity Engineer is an architectural mindset centered on asking questions that make software decisions and their implications easier to understand.
- five-step architectural thinking processA repeatable five-step method for analyzing software requests and making reasoned architectural decisions before implementation.
- availabilityThe duration or proportion of time a system remains operational.
- consistencyConsistency is the property that observations of distributed data conform to a defined agreement about its current state.
- maintainabilityMaintainability is the degree to which software can be understood, corrected, modified, or extended efficiently over time.
- separation of concernsSeparation of concerns is a design principle that reduces complexity by dividing a system into distinct parts with separate responsibilities and boundaries.
- layered architectureA structural division of software with a defined responsibility and relationships to other divisions.
- business logicBusiness logic is the application code that implements domain-specific rules and coordinates the system's behavior.
- sketchA sketch is an informal architecture diagram that represents a system’s main responsibilities and relationships without the formality of a UML diagram.
- scalabilityScalability is the ability of a system to maintain acceptable behavior as its workload or size increases.
- performancePerformance is the measurable responsiveness and efficiency of a software system, including the time it takes to serve requests.
- NoSQL databaseA database system that does not primarily use the relational table-and-SQL model and commonly supports a nonrelational data model.
- SQLSQL is a standardized language for defining, querying, and manipulating data in relational database systems.
- hexagonal architectureAn architectural pattern that isolates the application core from external systems through ports and adapters.
- observabilityObservability is the practice of making a distributed system's internal state inferable from externally emitted telemetry.
- principle of least privilegeA security principle that grants users, processes, and systems only the permissions necessary for their required functions.
- rest apiA REST API is a web API designed around resources and the constraints of Representational State Transfer.
- software testingTesting is the systematic evaluation of software behavior against expected requirements or properties.
- vector databaseA vector database is a database system optimized for storing, indexing, and querying numerical vector representations.
- sparkThe Spark is the initial feature request or observed problem that starts architectural discovery.
- cohesionCohesion is the degree to which the responsibilities within a software component belong together.
- couplingCoupling is the degree of dependency between software components, with tight coupling requiring extensive knowledge of another component's operations or internal structure.
- architectural decisionAn architectural decision is a choice that materially shapes a software system's structure, behavior, or quality attributes.
- system boundaryA separation that controls how responsibilities and dependencies cross between parts of a software architecture.
- event-driven architectureA software architecture in which components communicate and trigger processing by producing and consuming events.
- infrastructure as codeInfrastructure as Code is the practice of defining and managing infrastructure through machine-readable configuration files rather than manual procedures.
- microserviceA microservice is an independently deployable service aligned with a specific business capability and communicating with other services through defined interfaces.
- ilitiesSystem qualities such as reliability, scalability, and maintainability that describe how a system behaves or can be operated.
- cachingCaching is the technique of temporarily storing reusable data or results to reduce latency or repeated computation.
- graceful failureA resilience pattern in which a system continues providing reduced functionality when components or dependencies fail.
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.
