Chapter 2: Understanding the problem
The chapter introduction explains why engineers must understand the problem and its business context before choosing a technical solution.
After this chapter you will be able to
- Risk of premature solutions. Explain why reaching for an architecture or technology before defining the problem can lead to a poor decision.
- Engineers’ problem understanding. Explain why engineers must understand the business context rather than leave problem understanding entirely to product or business roles.
- Architecture-defining requirements. Explain why problem definition must go beyond a list of functional requirements to identify what people are trying to accomplish and which requirements could change the architecture if misunderstood.
- Needs behind solution requests. Explain how to move a discussion from a proposed system to the situation, people, and progress that matter. Describe how Jobs-to-Be-Done, Impact Mapping, or plain questions can keep attention on the problem before deciding what to build.
- Problem fit over reflex tools. Apply the section’s reframing to explain why a simpler change might serve a stated need better than a new tool, while recognizing when a purpose-built tool could still be appropriate.
- Firsthand signals for engineering. Explain why engineers making long-lived technical decisions benefit from observing user discovery or reviewing raw interview material, and describe the lightweight involvement the section recommends.
- Engineering input on viability. Explain why engineers should help shape requirements rather than only receive them: they can assess whether a proposed solution is secure, deployable, maintainable, and affordable to build and run.
- Search requirement versus user need. Trace how the proposed full-text search feature carried architectural and operational costs, and distinguish that proposed solution from the users' need to apply related filters faster.
- Architecturally significant requirements. Explain what makes a requirement architecturally significant and distinguish it from a requirement that matters for implementation but not foundational design.
- What would break this test. Describe how to apply the “what would break this” test to identify functional ASRs, using the search example to distinguish an architecture-changing requirement from a smaller adjustment.
- Likely needs beyond MVP scope. Justify looking beyond immediate MVP requirements when making foundational choices while avoiding investment in every hypothetical future need.
- Non-functional expectations and architecture. Explain how non-functional requirements differ from functional requirements, why engineers may need to surface and make them measurable, and how they can shape architecture.
- Service tier definition. Describe a service tier and explain why it groups expectations into ranges rather than demanding precise numbers.
- Failure consequences and investment. Justify assigning different specifications to services based on the consequences of failure, using the section’s examples.
- Availability tier trade-offs. Explain how the cost of downtime helps determine an appropriate availability tier and why different uses of similar technology may warrant different investments.
- Tier and SLO distinction. Distinguish an availability tier from a specific uptime target and explain how stakeholders can arrive at a Service Level Objective.
- Failure based durability tiers. Explain how to assess a durability tier by asking how much data loss is tolerable under a specific failure scenario and what the architecture actually protects against.
- Data loss consequences. Justify why rebuildable derived data may need less durability than source-of-truth records, using the search-index example and the consequences of losing each.
- Joint topology tradeoffs. Explain why availability and durability should be considered together when choosing deployment topology and justifying its cost.
- Human perception latency boundaries. Explain how perceived waiting changes at roughly 100 milliseconds, 300 milliseconds, one second, and ten seconds, and what those boundaries imply for interactive design.
- Percentile based latency targets. Explain why a request latency target is better expressed as a percentile than as an average or a requirement that every request comply, using p95 < 300 milliseconds as an example.
- Context dependent tier placement. Distinguish the latency tier appropriate for customer-facing storefront search from one appropriate for infrequent backoffice search, and explain what choosing a tier enables the team to do.
- Load throughput and scalability. Distinguish throughput, load, and scalability using the section’s definitions and examples.
- Component load profiles. Explain why average traffic and a single system-wide load figure are insufficient for sizing components.
- Peak scenarios and capacity choices. Describe how peak-load scenarios expose constraints and compare always-on peak capacity with dynamic autoscaling.
- Contextual load tiers. Explain why load tiers must be defined for a particular system and apply that distinction to storefront and backoffice search.
- Volatility and architectural investment. Explain how volatility tiers describe expected frequency of change and help determine reasonable investment in isolation and decoupling.
- Comparing service tier profiles. Explain how to compare systems on a spider diagram using availability, durability, latency, load, and volatility, and why different profiles should inform architectural choices even when the systems have similar features.
- Legal obligation applicability. Distinguish legal and regulatory obligations from continuous service properties, and explain why identifying applicable obligations is more useful than assigning a compliance tier.
- Security risk and control. Describe why security calls for identifying a system's concrete threats and matching controls to them, rather than treating security as binary or tiered.
- Requirements and controls distinction. Distinguish a required system property from the specific implementation chosen to satisfy it, using the section’s authentication-and-encryption example.
- Legal constraints on architecture. Explain where legal requirements come from and describe how they can affect system design, using examples from the section.
- Early legal clarification. Justify clarifying legal requirements early in design by explaining the cost of discovering a constraint after implementation has begun.
- Data inventory for compliance. Describe what a data inventory records and how creating one early helps legal stakeholders and engineering identify applicable constraints.
- Threat requirement control chain. Trace how threat modelling turns a system-specific threat into a security requirement and then a control, distinguishing the three layers and how changes can affect each.
- Early compliance involvement. Explain why legal, privacy, and security stakeholders should join conversations while architectural options are still open, and what those conversations should identify.
- Proportionate compliance controls. Explain how engineering and compliance stakeholders can jointly choose safeguards that meet a requirement without unnecessary complexity or ineffective restrictions.
- Requirement control traceability. Describe what to document when selecting a compliance control and why that record remains useful after launch.
- Architecture requirements and examples. Explain what architecture requirements constrain and give examples, such as deployment targets, approved technologies, shared design patterns, or internal components.
- Value of shared standards. Explain why architecture requirements should exist and what makes them valuable in practice.
- Readiness Without Completeness. Explain why a team can begin discussing solutions before every question is answered, provided it knows what is well-defined, what remains uncertain, and whether those gaps are acceptable.
- Open Solution Space. Explain how the backoffice-search example states the staff's job without prescribing a system, and distinguishes architecture-shaping requirements from implementation details.
What it builds on
- Phase 1: Framing the decision (chapter 1) · Builds on framing the decision before evaluating solutions.
Section by section
Introduction
The chapter introduction explains why engineers must understand the problem and its business context before choosing a technical solution.
- Risk of premature solutions: Explain why reaching for an architecture or technology before defining the problem can lead to a poor decision.
Why it matters: Defining the problem first helps prevent wasted effort on a solution that does not fit. - Engineers’ problem understanding: Explain why engineers must understand the business context rather than leave problem understanding entirely to product or business roles.
Why it matters: Engineers can improve the options available to the team when they understand the need behind a request.
Key terms: problem, solution, constraint, business context, requirements
2.1 Problem definition beyond requirements
The section frames problem definition as understanding what people are trying to accomplish and separating architecture-defining requirements from implementation details.
- Architecture-defining requirements: Explain why problem definition must go beyond a list of functional requirements to identify what people are trying to accomplish and which requirements could change the architecture if misunderstood.
Why it matters: It keeps attention on the needs and requirements that could materially change the design.
Key terms: problem definition, functional requirements, implementation detail, design-deciding requirement
2.1.1 From quick solutions to the real needs
This section shows how engineers can get past an initial request for a system to understand the need behind it, consider fitting alternatives, and hear user context firsthand.
- Needs behind solution requests: Explain how to move a discussion from a proposed system to the situation, people, and progress that matter. Describe how Jobs-to-Be-Done, Impact Mapping, or plain questions can keep attention on the problem before deciding what to build.
Why it matters: Naming the need first leaves room to find a better answer than the first system someone suggested. - Problem fit over reflex tools: Apply the section’s reframing to explain why a simpler change might serve a stated need better than a new tool, while recognizing when a purpose-built tool could still be appropriate.
Why it matters: A smaller change may meet the need without adding a system, though a dedicated tool may be justified later. - Firsthand signals for engineering: Explain why engineers making long-lived technical decisions benefit from observing user discovery or reviewing raw interview material, and describe the lightweight involvement the section recommends.
Why it matters: Firsthand user context can change which architectural trade-offs seem appropriate.
Key terms: pull toward solutions, underlying needs, Jobs-to-Be-Done, Impact Mapping, reflex solutions, purpose-built tool, best fit, discovery sessions, raw signals, product requirements
2.1.2 How engineering shapes the requirements
Engineering helps shape requirements by exposing feasibility and architectural costs early, so teams can meet the underlying user need at an acceptable cost.
- Engineering input on viability: Explain why engineers should help shape requirements rather than only receive them: they can assess whether a proposed solution is secure, deployable, maintainable, and affordable to build and run.
Why it matters: A desirable feature may not be a viable investment until its engineering implications are understood. - Search requirement versus user need: Trace how the proposed full-text search feature carried architectural and operational costs, and distinguish that proposed solution from the users' need to apply related filters faster.
Why it matters: Separating the user's job from a proposed feature makes room for solutions that deliver value without unnecessary architectural cost. - Timing of collaborative input: Explain why engineering feedback is more useful while product ideas are forming than after UX flows and stakeholder expectations have been established.
Why it matters: Early feedback can change an approach before substantial design work and stakeholder alignment make it harder to change.
Key terms: requirements, viable, engineering input, full-text search, synchronisation pipeline, operational overhead, guided filtering, product ideation workshop, design sprint, feasibility
2.1.3 Architecturally significant requirements
This section explains how to identify requirements that could change a system’s architecture and how to consider likely future needs without overengineering.
- Architecturally significant requirements: Explain what makes a requirement architecturally significant and distinguish it from a requirement that matters for implementation but not foundational design.
Why it matters: Spotting these requirements early can prevent a feature request from unexpectedly overturning foundational choices. - What would break this test: Describe how to apply the “what would break this” test to identify functional ASRs, using the search example to distinguish an architecture-changing requirement from a smaller adjustment.
Why it matters: The test directs early discussion toward architectural limits instead of trying to settle every feature detail. - Non-functional architectural weight: Explain why non-functional requirements are treated as ASRs by default in this section.
Why it matters: A feature list alone may conceal constraints that substantially change the design. - Likely needs beyond MVP scope: Justify looking beyond immediate MVP requirements when making foundational choices while avoiding investment in every hypothetical future need.
Why it matters: Considering likely near-term needs makes early simplicity an informed trade-off rather than a source of avoidable refactoring.
Key terms: Architecturally significant requirements, ASRs, foundational design, what would break this, minimal design, advanced relevance ranking, ASR, non-functional requirements, NFRs, scale
2.2 Thinking in service tiers
The section explains why engineers must make non-functional expectations explicit and introduces service tiers as a way to connect those expectations to architectural choices.
- Non-functional expectations and architecture: Explain how non-functional requirements differ from functional requirements, why engineers may need to surface and make them measurable, and how they can shape architecture.
Why it matters: An unstated expectation can still rule out an otherwise appealing design. - Service tier definition: Describe a service tier and explain why it groups expectations into ranges rather than demanding precise numbers.
Why it matters: A useful range can guide a design choice even when an exact target is unavailable. - Failure consequences and investment: Justify assigning different specifications to services based on the consequences of failure, using the section’s examples.
Why it matters: Matching specifications to the stakes helps avoid both needless expense and inadequate protection.
Key terms: functional requirements, non-functional requirements, ASR, service tier, non-functional expectation, architectural implications, service tiers, consequences of failure, over-engineering, under-engineering
2.2.1 Availability
Availability tiers turn uptime needs into a business conversation about the cost of downtime and the architectural investment it justifies.
- Availability tier trade-offs: Explain how the cost of downtime helps determine an appropriate availability tier and why different uses of similar technology may warrant different investments.
Why it matters: It keeps an uptime discussion focused on what the business needs and is willing to fund. - Tier and SLO distinction: Distinguish an availability tier from a specific uptime target and explain how stakeholders can arrive at a Service Level Objective.
Why it matters: It prevents a broad tier choice from being mistaken for a precise uptime commitment. - Availability requirement scope: Describe the usual scope of availability requirements and how that scope informs architectural investment.
Why it matters: Setting the requirement at the right scope helps direct redundancy spending where it is needed.
Key terms: availability tiers, downtime, High, Standard, Service Level Objective (SLO), uptime target, availability requirements, system, subsystem, standalone component
2.2.2 Durability
This section explains how to judge data durability by the consequences of loss and the failures a design protects against, while considering durability alongside availability.
- Availability and durability distinction: Distinguish a system being available from its data surviving a failure, including why a quick recovery does not guarantee that recent writes survived.
Why it matters: Separating the two concerns helps reveal data-loss risks that a recovery-time target might hide. - Failure based durability tiers: Explain how to assess a durability tier by asking how much data loss is tolerable under a specific failure scenario and what the architecture actually protects against.
Why it matters: A failure-specific guarantee makes a durability target more useful than an unsupported claim that data is safe. - Data loss consequences: Justify why rebuildable derived data may need less durability than source-of-truth records, using the search-index example and the consequences of losing each.
Why it matters: Different data can warrant different protection even within the same system. - Joint topology tradeoffs: Explain why availability and durability should be considered together when choosing deployment topology and justifying its cost.
Why it matters: The same deployment expense can buy both service continuity and protection against data loss.
Key terms: availability, durability, durability forces, failure scenario, architectural guarantees, tiers, source of truth, search index, reindex, durability tiers
2.2.3 Latency
The section shows how human perception and usage context turn latency expectations into service tiers that guide targets and engineering trade-offs.
- Human perception latency boundaries: Explain how perceived waiting changes at roughly 100 milliseconds, 300 milliseconds, one second, and ten seconds, and what those boundaries imply for interactive design.
Why it matters: Perception-based boundaries make latency targets meaningful to both engineers and stakeholders. - Percentile based latency targets: Explain why a request latency target is better expressed as a percentile than as an average or a requirement that every request comply, using p95 < 300 milliseconds as an example.
Why it matters: A percentile gives a team a latency target it can design, test, and monitor against without demanding perfection on every request. - Context dependent tier placement: Distinguish the latency tier appropriate for customer-facing storefront search from one appropriate for infrequent backoffice search, and explain what choosing a tier enables the team to do.
Why it matters: A context-specific tier directs effort toward latency improvements that are worth making. - Caching costs and tier fit: Justify why a team should check a query's latency tier and simpler datastore optimizations before adding a cache solely to make responses faster.
Why it matters: Checking the tier before adding a cache can avoid complexity that provides little user benefit.
Key terms: latency, service tiers, synchronous path, asynchronous, percentile, p95, latency expectations, Responsive tier, Acceptable, backoffice
2.2.4 Load
This section explains how to describe load, plan for peaks, and choose scalability measures that fit each component’s actual demand.
- Load throughput and scalability: Distinguish throughput, load, and scalability using the section’s definitions and examples.
Why it matters: These distinctions prevent a throughput number from standing in for the whole scaling problem. - Component load profiles: Explain why average traffic and a single system-wide load figure are insufficient for sizing components.
Why it matters: Sizing for the wrong workload can produce both failures at peaks and unnecessary complexity elsewhere. - Peak scenarios and capacity choices: Describe how peak-load scenarios expose constraints and compare always-on peak capacity with dynamic autoscaling.
Why it matters: A specific peak scenario makes both hidden bottlenecks and the cost–complexity trade-off discussable. - Contextual load tiers: Explain why load tiers must be defined for a particular system and apply that distinction to storefront and backoffice search.
Why it matters: Contextual tiers help teams invest in peak handling where it is justified without imposing it everywhere. - Proportionate scalability planning: Justify when a team can deprioritize throughput planning and when a coarse tiering approach may be insufficient.
Why it matters: The point is to make a deliberate scaling assessment, not to apply the same planning process to every product.
Key terms: throughput, load, scalability, load profile, daily peaks, read-heavy paths, write-heavy ones, background processing, peak load scenarios, worst case
2.2.5 Volatility
The section treats expected frequency of change as a non-functional requirement that should influence architectural investment.
- Volatility and architectural investment: Explain how volatility tiers describe expected frequency of change and help determine reasonable investment in isolation and decoupling.
Why it matters: It helps you spend architectural effort where the expected pattern and cost of change justify it. - Different volatility within search: Describe why item-search ranking logic and the underlying index schema call for different approaches to change.
Why it matters: The search example shows why a single system need not have one uniform approach to change. - Changing volatility tiers: Explain why a component’s volatility tier may need to be revisited as the business comes to rely on it.
Why it matters: A design suited to a short-lived campaign may need reconsideration when that component becomes an established part of the business.
Key terms: volatility, volatility tiers, isolation, decoupling, foundational components, campaign components, ranking and relevance logic, configuration-driven ranking rules, feature-flagged algorithms, index schema
2.2.6 Comparing service tiers
The section shows how comparing systems across five service-tier dimensions reveals differences that should shape architectural choices before solution discussions begin.
- Comparing service tier profiles: Explain how to compare systems on a spider diagram using availability, durability, latency, load, and volatility, and why different profiles should inform architectural choices even when the systems have similar features.
Why it matters: A shared feature label such as “search” does not mean two systems need the same architecture or justify the same costs.
Key terms: service tiers, spider diagram, availability, durability, latency, load
2.3 Compliance requirements
This section explains why compliance needs a different approach from tiered non-functional requirements: legal obligations depend on applicability, while security depends on specific risks and controls.
- Compliance as a distinct category: Explain why compliance is treated separately from other non-functional requirements, even though it shares that label.
Why it matters: It explains why the usual engineering conversation about non-functional requirements is not sufficient for compliance. - Legal obligation applicability: Distinguish legal and regulatory obligations from continuous service properties, and explain why identifying applicable obligations is more useful than assigning a compliance tier.
Why it matters: The first question for a legal obligation is whether the system has inherited it, not which service tier to choose. - Security risk and control: Describe why security calls for identifying a system's concrete threats and matching controls to them, rather than treating security as binary or tiered.
Why it matters: A security discussion needs to stay tied to the system's actual threats rather than a generic level.
Key terms: compliance requirements, non-functional, service tiers, continuous properties, legal and regulatory obligations, security, risk-and-control, threats, controls
2.3.1 Separating requirements from controls
The section distinguishes compliance requirements from the controls used to satisfy them and explains how to maintain and select those controls.
- Requirements and controls distinction: Distinguish a required system property from the specific implementation chosen to satisfy it, using the section’s authentication-and-encryption example.
Why it matters: Keeping the obligation separate from its implementation preserves architectural flexibility. - Documenting the requirement control link: Explain why the relationship between a requirement and its control should be documented and revisited.
Why it matters: A documented link makes it possible to update an implementation while keeping its obligation clear. - Expert and engineering responsibilities: Describe who turns regulations into system requirements and why control selection should involve engineering as well as specialists.
Why it matters: Joint selection brings the relevant obligations and engineering trade-offs into the same decision.
Key terms: requirement, control, threat models, legal, compliance, or security specialists, controls, implementation complexity, legal or security risks
2.3.2 Legal requirements
This section explains how legal and contractual requirements constrain architecture, why they must be identified early, and how a data inventory helps map them to design decisions.
- Legal constraints on architecture: Explain where legal requirements come from and describe how they can affect system design, using examples from the section.
Why it matters: These obligations can determine what an architecture must support, not just what the product does. - Early legal clarification: Justify clarifying legal requirements early in design by explaining the cost of discovering a constraint after implementation has begun.
Why it matters: Asking about legal constraints before committing to a design can avoid expensive changes later. - Data inventory for compliance: Describe what a data inventory records and how creating one early helps legal stakeholders and engineering identify applicable constraints.
Why it matters: An inventory gives legal and engineering teams a shared, concrete basis for finding design constraints early.
Key terms: legal requirements, data residency, right to erasure, contractual obligations, costly redesign, legal, data inventory, personal or regulated data, jurisdictions, retention
2.3.3 Security requirements
This section explains where security requirements come from and how teams derive system-specific requirements from threats before choosing controls.
- Sources and limits of security requirements: Explain that security requirements can come from industry best practices and applicable standards or regulations, but those sources do not cover every risk specific to a system.
Why it matters: A standards checklist may miss risks particular to your system. - Centralized security requirements catalog: Justify keeping a centralized security requirements catalog grouped by use case rather than making each engineering team rediscover policies and obligations for every project.
Why it matters: It makes applicable requirements easier for teams to find and apply consistently. - Threat requirement control chain: Trace how threat modelling turns a system-specific threat into a security requirement and then a control, distinguishing the three layers and how changes can affect each.
Why it matters: Separating these layers shows why a defense is needed and what must change when risks or technology change. - Collaborative threat modelling: Explain why threat modelling works best as a discussion among engineers, security experts, and product managers rather than a security-team artefact for others to review.
Why it matters: The people who understand the product and system can help identify threats a security team might otherwise miss.
Key terms: industry best practices, standards and regulations, security requirements, security requirements catalogs, use case, threat modelling, threats, security requirement, control, collaborative discussion
2.3.4 Common tips for addressing compliance requirements
The section explains how to address legal and security requirements collaboratively: involve specialists early, choose proportionate controls, and record why each control was chosen.
- Early compliance involvement: Explain why legal, privacy, and security stakeholders should join conversations while architectural options are still open, and what those conversations should identify.
Why it matters: An early constraint can change the architecture; discovering it near the due date makes that change disruptive. - Proportionate compliance controls: Explain how engineering and compliance stakeholders can jointly choose safeguards that meet a requirement without unnecessary complexity or ineffective restrictions.
Why it matters: A safeguard works best when it meets the legal or security need without imposing avoidable cost or creating only an illusion of compliance. - Requirement control traceability: Describe what to document when selecting a compliance control and why that record remains useful after launch.
Why it matters: A short, findable record preserves the reasoning needed to maintain compliance when people, regulations, or threats change.
Key terms: compliance stakeholders, architectural options, constraints, compliance requirements, controls, risk, sensitivity, proportional safeguards, requirements, threat
2.3.5 What about architecture requirements?
This section defines architecture requirements as internal constraints on system design and deployment and explains when those constraints provide value.
- Architecture requirements and examples: Explain what architecture requirements constrain and give examples, such as deployment targets, approved technologies, shared design patterns, or internal components.
Why it matters: These constraints can narrow technical choices before a team compares solutions. - Value of shared standards: Explain why architecture requirements should exist and what makes them valuable in practice.
Why it matters: A shared standard is easier to justify when it reduces work for teams rather than adding friction.
Key terms: architecture requirements, compliance requirements, deployment targets, approved languages, frameworks, or libraries, consistency, simplify operations, well-supported path, shared component library, mature deployment platform
2.4 When the problem is ready for solution discussion
The section explains when a problem description is sufficiently clear to discuss solutions and shows how a backoffice-search example keeps needs and constraints distinct from implementation choices.
- Readiness Without Completeness: Explain why a team can begin discussing solutions before every question is answered, provided it knows what is well-defined, what remains uncertain, and whether those gaps are acceptable.
Why it matters: This helps a team avoid both premature solution discussions and analysis that delays useful design work. - Open Solution Space: Explain how the backoffice-search example states the staff's job without prescribing a system, and distinguishes architecture-shaping requirements from implementation details.
Why it matters: Separating the need from a proposed implementation lets the team consider alternatives without overlooking requirements that shape the architecture. - Structured Problem Constraints: Describe what the simplified problem understanding records beyond the job: significant requirements, service tiers for non-functional dimensions, compliance constraints and their controls, and applicable architectural standards.
Why it matters: Making these constraints explicit gives a solution discussion a shared starting point without locking every detail in place.
Key terms: problem understanding, ready for solutions discussion, job, solution space, ASRs, architecture-shaping, implementation details, non-functional dimension, service tier, compliance constraint
2.5 Summary
Where this is used later
- (chapter intro) (chapter 4) · Distinguishing an appealing solution from the real need.
- Screening against key requirements (chapter 4) · Screening technology candidates against the requirements they must actually meet.
- Understanding licences (chapter 4) · Separating a compliance requirement from a particular control helps frame customer licence restrictions as constraints to check.
- Technology strategy (chapter 3) · Provides a basis for recognizing how organization-wide technology standards shape a choice.
- (chapter intro) (chapter 3) · The distinction between understanding the problem and being ready to discuss solutions.
- System context (chapter 3) · Understanding the problem and requirements before discussing solutions.
- Qualifying candidates (chapter 4) · Establishing the problem before discussing solutions.
Concepts explained in this chapter
- nonfunctional requirementA requirement that specifies a system quality, constraint, or performance expectation rather than a function the system performs.
- architectural requirementAn architecturally significant requirement is a requirement whose correctness or fulfillment can determine or substantially change a system's architecture.
- security controlA measure intended to mitigate a security threat or satisfy a security or compliance requirement.
- compliance requirementAn obligation that a system or organization must satisfy to meet applicable legal, regulatory, or other standards.
- service tierA service tier is a named category representing a range of non-functional expectations with similar architectural implications.
- throughputThroughput is the amount of work or number of operations a system completes per unit of time.
- jobs-to-be-doneJobs-to-Be-Done is a product-management framework that explains adoption in terms of customers hiring products to make progress in a circumstance.
- durabilityThe ability of a system to preserve data or completed operations despite failures or interruptions.
- complianceAdherence to applicable laws, regulations, standards, or other obligations.
- system loadThe amount and kind of work a system must handle, such as request rates, data volume, concurrent users, and operations.
- problem understandingProblem understanding is the work of clarifying the problem, its context, and relevant constraints before choosing a solution.
- riskA risk is a potential adverse event or consequence that may affect a decision or its results.
- decision qualityThe merit of a decision as judged by the reasoning and process behind it rather than solely by its eventual outcome.
- guardrailA boundary or guideline that constrains choices while allowing teams to make decisions within it.
- tradeoffA trade-off is a choice in which improving one consideration may require accepting a cost or limitation in another.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
