Chapter 4: Design for evolution: architecture that survives change
The chapter introduction explains why architecture must remain effective as a system’s context changes, rather than merely preserve its initial design.
After this chapter you will be able to
- Changing Context and Architectural Fitness. Explain why a system needs to keep working as its context changes and why an architecture that is good enough today may not remain so.
- Guided Versus Unmanaged Evolution. Distinguish unmanaged system evolution from evolution guided by architectural awareness, and describe the value of keeping structures and decisions adaptable.
- Continuing system change. Explain why a system remains subject to change throughout its lifetime, even when feature development stops or the software is delivered as a boxed product.
- Observable behavior dependencies. Explain why changing an API safely may require understanding more than its formal contract.
- Success driven architectural pressure. Explain how unexpected success can make an initially reasonable architecture inadequate, and describe how signals and contingency questions help expose that risk without overengineering from day one.
- Evolvability as a design requirement. Explain why scalability, performance, and reliability are not enough for a system expected to last beyond its first release. Describe evolvability as the ability to absorb change without disproportionate effort.
- Modularity and safe change. Describe how clear boundaries, loose coupling, and high cohesion make a module easier to change without forcing unrelated modules to change.
- Observability of change effects. Explain how operational signals let a team judge the effects of a released change and notice when architectural assumptions stop holding.
- Limited change blast radius. Describe change isolation and how boundaries, contracts, tests, and ownership help keep a failed change's impact understandable and limited.
- Early signs of rigidity. Explain how recurring friction can reveal that an architecture is no longer absorbing change well, even when the system still appears stable.
- Architectural feedback loop. Trace how sensing mechanisms turn change signals into decisions and how the results feed the next decision.
- Lightweight feedback habit. Apply the section’s suggested starting approach to a recurring architectural pain point.
- Selective preparation for change. Explain how to distinguish changes worth preparing for from speculative possibilities, and why preparation should be proportionate to the risk.
- Last responsible decision moment. Explain the last responsible moment and apply the section's decision factors to distinguish useful waiting from harmful delay.
- Premature architectural commitments. Explain that the last responsible moment means avoiding early decisions that are expensive to reverse, not postponing decisions indefinitely. Describe forms of lock-in beyond cloud vendors, such as an early domain model, integration contract, architectural pattern, or technology choice.
- Decision timing and flexibility. Apply the section's questions to judge whether a decision is needed now: identify blocked work, the assumption being locked in, information waiting may provide, reversal cost, and the risk of delay. Explain that a smaller decision or an option-preserving measure may allow the larger choice to wait.
- Purpose and placement of seams. Explain how seams make later changes safer and where they should be placed. Describe why adding seams everywhere is counterproductive.
- Incremental legacy capability replacement. Trace how the Strangler Fig pattern introduces a new implementation alongside a legacy system, gradually redirects traffic capability by capability, and retires old capabilities.
- Risk control and seam prerequisites. Explain why incremental replacement reduces risk and describe what boundaries make the approach workable, including what to do if they are absent.
- Decision context and reasoning. Explain what an ADR records and why preserving the reasoning matters as systems and teams change.
- Review triggers for decisions. Describe how an ADR can state when a decision should be reconsidered, using the modular-monolith example.
- Softness under ordinary change. Explain how an ordinary change request reveals whether an architecture is soft or rigid, using the fraud-check example to describe the difference in impact.
- Distribution without service autonomy. Explain when microservices help a system evolve and why they can instead become a distributed monolith.
- Modular monolith as alternative. Justify choosing a modular monolith when the need or capability for distribution is not yet present.
- Essential and accidental complexity. Distinguish complexity inherent in a system’s requirements from complexity introduced by its design, using the order-processing example.
- Complexity and architectural softness. Explain how unnecessary design complexity can impede evolution and how an architect judges whether it remains justified.
- Architectural complexity and team readiness. Explain why an advanced architectural design can become fragile when the team is not ready to understand, operate, and evolve it.
- Capability growth alongside architecture. Explain the leadership response when future architectural ambitions exceed the team's current capabilities.
- Compatibility and independent releases. Explain why backward compatibility makes evolution safer when producers and consumers move at different speeds, and what happens when it is not designed in.
- Contract changes and safeguards. Describe how to protect compatibility through contract design, automated checks, and planned support for older versions.
- Compatibility approaches across boundaries. Distinguish how versioned APIs, metadata-enveloped messages, and additive events help different consumers handle evolving contracts.
- Request and event trade-offs. Distinguish when direct requests are a reasonable choice from when publishing an event creates a useful seam for independently changing components.
- Conditions for event-driven evolvability. Explain why event-driven design does not automatically improve evolvability and describe the section’s test for whether it helps or hurts.
- Conscious managed-service adoption. Explain why a new managed cloud service should be treated as an architectural decision rather than a simple provisioning choice, and describe when adopting one can still be the better choice.
- Selective seams and stable contracts. Explain how stable contracts and boundaries let implementations change without disrupting consumers, and why volatile dependencies should be isolated only where replacement is plausible or lock-in would be costly.
- Replacement in controlled slices. Describe why replaceability requires the ability to redirect, substitute, or retire parts of a system incrementally rather than relying on a big-bang migration.
- Evolvability review and revisit triggers. Apply the evolvability review to identify plausible change, what must stay stable, what should remain flexible, and the signals or triggers for revisiting a decision. Explain why major architectural decisions should be managed consciously over time.
- Organizational conditions for evolvability. Explain why an architecture cannot remain evolvable unless the responsible team can grow and discuss, test, and adopt change without fear.
- Reviewable decisions and learning. Describe how teams can make architectural decisions and incidents useful for learning rather than personal criticism or blame. Explain why decision context should remain visible and updateable.
- Shared ownership and capability growth. Explain how pairing on risky areas, raising design concerns early, and developing team capabilities help a team make deliberate architectural changes.
- Architectural stewardship of change. Explain how an architect supports a system’s ability to change while keeping it useful over time.
What it builds on
- How to know if architecture is “good enough” (chapter 3) · The idea of judging whether architecture is good enough for its current context.
- Good enough architecture: the art of trade-offs (chapter 3) · Architectural choices involve trade-offs rather than a universally perfect answer.
- Architecture reality: evolution as a cornerstone (chapter 3) · Introduces evolution as a cornerstone of architecture.
- Team skills and maturity (chapter 2) · Team skills and maturity as a force shaping architectural choices.
Section by section
Introduction
The chapter introduction explains why architecture must remain effective as a system’s context changes, rather than merely preserve its initial design.
- Changing Context and Architectural Fitness: Explain why a system needs to keep working as its context changes and why an architecture that is good enough today may not remain so.
Why it matters: A design cannot be judged only against the circumstances in which it began. - Guided Versus Unmanaged Evolution: Distinguish unmanaged system evolution from evolution guided by architectural awareness, and describe the value of keeping structures and decisions adaptable.
Why it matters: The way change is guided affects whether future changes become safer or harder.
Key terms: good-enough architecture, assumptions, context, big ball of mud, spaghetti architecture, architectural awareness
4.1 Systems never sit still
This section shows why systems must be able to respond to ongoing, sometimes unexpected change rather than being treated as finished.
- Continuing system change: Explain why a system remains subject to change throughout its lifetime, even when feature development stops or the software is delivered as a boxed product.
Why it matters: Treating change as normal makes it easier to recognize when an architecture needs room to adapt. - Plausible change pressures: Describe how to examine likely change pressures on a familiar system without claiming to predict its future perfectly.
Why it matters: A simple pressure check can reveal risks worth preparing for without requiring a perfect forecast. - Observable behavior dependencies: Explain why changing an API safely may require understanding more than its formal contract.
Why it matters: An apparently internal or undocumented change can still disrupt consumers. - Success driven architectural pressure: Explain how unexpected success can make an initially reasonable architecture inadequate, and describe how signals and contingency questions help expose that risk without overengineering from day one.
Why it matters: A system can fail because it cannot adapt quickly enough to its own success.
Key terms: evolution, boxed products, change pressures, likelihood, impact, current readiness, owner, Hyrum’s Law, observable behavior, formal contract
4.2 Evolution as a first-class architectural quality
The section defines evolvability as a necessary architectural quality and gives five practical ways to judge whether a system can change safely.
- Evolvability as a design requirement: Explain why scalability, performance, and reliability are not enough for a system expected to last beyond its first release. Describe evolvability as the ability to absorb change without disproportionate effort.
Why it matters: A system that works well today may still become costly to maintain if ordinary changes require disproportionate effort. - Modularity and safe change: Describe how clear boundaries, loose coupling, and high cohesion make a module easier to change without forcing unrelated modules to change.
Why it matters: Good boundaries keep a local change from becoming work across unrelated modules. - Component replaceability: Explain what lets a team rewrite, replace, or upgrade a component without destabilizing its surroundings. Describe what the team should be able to identify before replacing it.
Why it matters: Replaceability lowers the cost of correcting an earlier architectural decision. - Extensibility without overdesign: Distinguish adding a likely feature at a known boundary from building extension points for every imagined future. Explain how extensibility avoids breaking existing contracts or changing unrelated areas.
Why it matters: Designing for likely additions helps future work without paying for speculative flexibility. - Observability of change effects: Explain how operational signals let a team judge the effects of a released change and notice when architectural assumptions stop holding.
Why it matters: A team cannot safely evolve behavior whose effects it cannot see. - Limited change blast radius: Describe change isolation and how boundaries, contracts, tests, and ownership help keep a failed change's impact understandable and limited.
Why it matters: A bounded failure lets the team correct a change without putting the entire system at risk.
Key terms: evolvability, good-enough architecture, modularity, boundaries, coupling, cohesion, replaceability, stable contracts, ownership, consumers
4.3 Feedback loops and sensing change
This section shows how lightweight feedback loops reveal architectural rigidity early enough for teams to decide deliberately whether to defer, adapt, or replace a design.
- Early signs of rigidity: Explain how recurring friction can reveal that an architecture is no longer absorbing change well, even when the system still appears stable.
Why it matters: Recognizing patterns of friction lets a team respond before a large rewrite becomes its only option. - Maintenance changes as signals: Describe how seemingly routine updates can expose brittleness and why they need safeguards.
Why it matters: A small-looking update can reveal a fragile design or cause an incident if its wider effects go unchecked. - Architectural feedback loop: Trace how sensing mechanisms turn change signals into decisions and how the results feed the next decision.
Why it matters: The loop turns otherwise scattered symptoms into deliberate architectural choices that can be revisited as their effects emerge. - Lightweight feedback habit: Apply the section’s suggested starting approach to a recurring architectural pain point.
Why it matters: Starting with a real recurring problem makes architectural feedback useful enough to become a regular habit.
Key terms: change signals, architectural rigidity, feedback, dependency updates, automated tests, observability, rollback plans, feedback loops, sensing mechanisms, architectural drift
4.4 Designing with future change in mind
This section explains how to prepare for plausible future changes without overbuilding and how to time architectural decisions at the last responsible moment.
- Selective preparation for change: Explain how to distinguish changes worth preparing for from speculative possibilities, and why preparation should be proportionate to the risk.
Why it matters: Selective preparation keeps change possible without making today's system needlessly rigid. - Last responsible decision moment: Explain the last responsible moment and apply the section's decision factors to distinguish useful waiting from harmful delay.
Why it matters: Good timing preserves flexibility without turning a postponed decision into a delivery risk.
Key terms: plausible change, speculative change, seam, stable contract, deferred risk, last responsible moment, cost of waiting, cost of reversal, uncertainty, delivery risk
4.4.1 Avoiding premature commitment
This subsection explains how to avoid hard-to-reverse architecture decisions before they are necessary, while recognizing when waiting creates delivery risk.
- Premature architectural commitments: Explain that the last responsible moment means avoiding early decisions that are expensive to reverse, not postponing decisions indefinitely. Describe forms of lock-in beyond cloud vendors, such as an early domain model, integration contract, architectural pattern, or technology choice.
Why it matters: Recognizing less obvious forms of lock-in helps you preserve flexibility where change would be costly. - Decision timing and flexibility: Apply the section's questions to judge whether a decision is needed now: identify blocked work, the assumption being locked in, information waiting may provide, reversal cost, and the risk of delay. Explain that a smaller decision or an option-preserving measure may allow the larger choice to wait.
Why it matters: These questions turn a vague preference for flexibility into a decision about whether waiting is safe and useful.
Key terms: last responsible moment, premature commitment, vendor lock-in, real delivery risk, smaller decision, seam, adapter, feature flag, versioned contract
4.4.2 Designing seams
This section explains how deliberately placed seams contain change and give an architecture room to evolve without adding unnecessary indirection.
- Purpose and placement of seams: Explain how seams make later changes safer and where they should be placed. Describe why adding seams everywhere is counterproductive.
Why it matters: A well-placed seam preserves room to change without making the whole system harder to work with. - Third-party dependency façade: Describe how a façade or adapter in front of a change-prone third-party API reduces the blast radius of provider changes.
Why it matters: Containing a provider change at one boundary can spare the rest of the system from widespread modifications. - Messaging as an evolving seam: Explain how a queue can begin as a narrow seam between components and gain capabilities as demand grows.
Why it matters: A modest queue can create room for later improvements without requiring a full event-driven platform up front.
Key terms: seams, stable interfaces, unnecessary indirection, façade, adapter, third-party API, blast radius, messaging, queue, timing and lifecycle
4.4.3 The Strangler Fig pattern
The section explains how the Strangler Fig pattern replaces a legacy system incrementally through seams, reducing the risk of a single large rewrite.
- Incremental legacy capability replacement: Trace how the Strangler Fig pattern introduces a new implementation alongside a legacy system, gradually redirects traffic capability by capability, and retires old capabilities.
Why it matters: It gives you a way to change a running system without replacing everything at once. - Risk control and seam prerequisites: Explain why incremental replacement reduces risk and describe what boundaries make the approach workable, including what to do if they are absent.
Why it matters: The pattern’s safety depends on both limiting each replacement and having boundaries that let you make the switch.
Key terms: Strangler Fig pattern, legacy system, seams, gradual traffic shift, risk control, big-bang replacement, routing points, integration boundaries, database ownership boundaries
4.4.4 Architecture decision records (ADR)
This subsection explains how lightweight architecture decision records preserve the reasoning behind decisions and help future teams revisit them when circumstances change.
- Decision context and reasoning: Explain what an ADR records and why preserving the reasoning matters as systems and teams change.
Why it matters: A written rationale helps a new team evaluate a decision rather than reverse it without understanding its original constraints. - Review triggers for decisions: Describe how an ADR can state when a decision should be reconsidered, using the modular-monolith example.
Why it matters: Review triggers give future teams a reasoned starting point for adaptation instead of treating an old decision as fixed. - Proportionate architecture documentation: Explain how the section positions ADRs alongside other architecture documentation and how a team should choose the amount of documentation.
Why it matters: Matching documentation to the situation preserves useful context without assuming every team needs the same process or tools.
Key terms: Architecture Decision Records, ADRs, context, alternatives, trade-offs, review triggers, revisit conditions, modular monolith, lightweight record, architecture documentation
4.5 Keeping architecture soft, not rigid
This section explains how to recognize architectural softness through ordinary changes and why an evolvable system should permit deliberate replacement when needed.
- Softness under ordinary change: Explain how an ordinary change request reveals whether an architecture is soft or rigid, using the fraud-check example to describe the difference in impact.
Why it matters: The effort and disruption caused by routine changes are a practical test of whether a system can evolve. - Deliberate replacement over rescue: Distinguish unnecessary rewrites caused by rigidity from responsible rewrites when the original system no longer fits, and explain how replacement should proceed.
Why it matters: An architecture can remain evolvable even when a substantial replacement becomes the responsible choice.
Key terms: architectural softness, stable boundary, tight coupling, cognitive load, evolutionary architecture, premature rigidity, hidden coupling, controlled risk, big-bang rescue
4.5.1 Modular monolith vs. distributed monolith
This section explains why distributing a system too early can create rigidity, and when a modular monolith is a better choice than microservices.
- Distribution without service autonomy: Explain when microservices help a system evolve and why they can instead become a distributed monolith.
Why it matters: Separate services are useful only if they actually let teams work and release more independently. - Modular monolith as alternative: Justify choosing a modular monolith when the need or capability for distribution is not yet present.
Why it matters: Clear boundaries can support change now without forcing a team to take on distribution costs before it is ready.
Key terms: microservices, distributed monolith, independent team ownership, responsibility boundaries, modular monolith, clear boundaries, distributed architecture
4.5.2 Avoiding accidental complexity
The section distinguishes unavoidable problem complexity from design-created complexity and explains why architects should challenge complexity that makes change harder without solving a real need.
- Essential and accidental complexity: Distinguish complexity inherent in a system’s requirements from complexity introduced by its design, using the order-processing example.
Why it matters: The distinction helps you avoid treating every architectural complication as a necessary part of the business problem. - Complexity and architectural softness: Explain how unnecessary design complexity can impede evolution and how an architect judges whether it remains justified.
Why it matters: Questioning complexity before it becomes entrenched helps preserve the system’s ability to change.
Key terms: essential complexity, accidental complexity, context boundaries, evolution paralysis, architectural softness
4.5.3 Team maturity matters
This section explains why architectural complexity must be introduced at a pace the team can operate and evolve, with stakeholder communication and team development supporting that path.
- Architectural complexity and team readiness: Explain why an advanced architectural design can become fragile when the team is not ready to understand, operate, and evolve it.
Why it matters: A sound design on paper can still be difficult to run and change in practice. - Stakeholder conversations about sequencing: Describe how to discuss a proposed advanced architecture with stakeholders when adopting it all at once would be risky.
Why it matters: Sequencing makes it possible to discuss risk without dismissing the goal or blaming the team. - Capability growth alongside architecture: Explain the leadership response when future architectural ambitions exceed the team's current capabilities.
Why it matters: Long-term architectural goals need a deliberate path for the team to become able to deliver and sustain them.
Key terms: team maturity, operational and cognitive demands, operational fragility, sequencing, milestones, capability growth, delivery risk, training, mentoring, pairing
4.5.4 Backward compatibility and versioning
This section explains how backward-compatible contracts and deliberate versioning let producers and consumers change at different speeds without forcing coordinated releases.
- Compatibility and independent releases: Explain why backward compatibility makes evolution safer when producers and consumers move at different speeds, and what happens when it is not designed in.
Why it matters: Compatibility gives teams room to release changes without requiring every consumer to move at once. - Contract changes and safeguards: Describe how to protect compatibility through contract design, automated checks, and planned support for older versions.
Why it matters: Treating contracts as tested promises helps prevent a seemingly small change from breaking existing users. - Compatibility approaches across boundaries: Distinguish how versioned APIs, metadata-enveloped messages, and additive events help different consumers handle evolving contracts.
Why it matters: The appropriate compatibility approach depends on whether consumers use an API, asynchronous messages, or events.
Key terms: backward compatibility, producers, consumers, contract, schema validation, contract tests, versioned test suites, deprecation policies, versioned APIs, metadata-enveloped messages
4.5.5 Event-driven vs. request-driven evolvability
This section explains when request-driven or event-driven design better supports change, and why loose coupling depends on operational clarity as well as structure.
- Request and event trade-offs: Distinguish when direct requests are a reasonable choice from when publishing an event creates a useful seam for independently changing components.
Why it matters: The better choice depends on how the process changes, not on a blanket preference for events. - Conditions for event-driven evolvability: Explain why event-driven design does not automatically improve evolvability and describe the section’s test for whether it helps or hurts.
Why it matters: An event-based design is only more evolvable if the team can understand, own, and troubleshoot it in production.
Key terms: request-driven design, OrderPlaced event, producer, consumers, seam, topology, ownership, contracts, failure modes, operational implications
4.6 Cloud-specific evolution traps
This section explains how cloud services can speed delivery while creating costs, operational burdens, and constraints on future change if adopted without deliberate evaluation.
- Conscious managed-service adoption: Explain why a new managed cloud service should be treated as an architectural decision rather than a simple provisioning choice, and describe when adopting one can still be the better choice.
Why it matters: A service that speeds the first release should not make later changes unnecessarily difficult. - Cloud service operating burden: Describe how sophisticated services and managed-service sprawl can outpace a team’s operational readiness, including their effects on cost.
Why it matters: The accumulated work and expense of cloud dependencies can outweigh their initial convenience. - Configuration and platform binding traps: Explain how Infrastructure-as-Code drift and serverless bindings can make later changes harder, despite shortcuts or speed in the present.
Why it matters: Early shortcuts can make future changes harder even when they help a team deliver quickly now.
Key terms: managed services, architectural decisions, provisioning choices, cost amplification, organizational readiness, managed-service sprawl, Infrastructure-as-Code drift, serverless binding lock-in, reproducibility
4.7 Designing for incremental replaceability
The section explains how to prepare an architecture for controlled, incremental replacement and how to review where that flexibility is worth preserving.
- Selective seams and stable contracts: Explain how stable contracts and boundaries let implementations change without disrupting consumers, and why volatile dependencies should be isolated only where replacement is plausible or lock-in would be costly.
Why it matters: The right boundaries make likely changes manageable without adding abstractions everywhere. - Replacement in controlled slices: Describe why replaceability requires the ability to redirect, substitute, or retire parts of a system incrementally rather than relying on a big-bang migration.
Why it matters: Replacing one part at a time avoids making every necessary change a disruptive transition. - Evolvability review and revisit triggers: Apply the evolvability review to identify plausible change, what must stay stable, what should remain flexible, and the signals or triggers for revisiting a decision. Explain why major architectural decisions should be managed consciously over time.
Why it matters: A review connects today's design choices to the changes and evidence that may justify revising them later.
Key terms: contracts, boundaries, design seams, selective replaceability, compatibility, incremental replaceability, Strangler Fig pattern, redirection, substitution, incremental retirement
4.8 Evolution as collaboration
Evolutionary architecture depends on team conditions and everyday habits that make change safe to discuss, learn from, and carry out.
- Organizational conditions for evolvability: Explain why an architecture cannot remain evolvable unless the responsible team can grow and discuss, test, and adopt change without fear.
Why it matters: Technical flexibility is useful only when people have the trust and opportunity to act on it. - Reviewable decisions and learning: Describe how teams can make architectural decisions and incidents useful for learning rather than personal criticism or blame. Explain why decision context should remain visible and updateable.
Why it matters: Reviewable choices and blameless learning help the team change course when evidence changes. - Shared ownership and capability growth: Explain how pairing on risky areas, raising design concerns early, and developing team capabilities help a team make deliberate architectural changes.
Why it matters: Shared knowledge and growing skills give the team the ownership needed to act on problems before change becomes costly.
Key terms: evolvability, psychological safety, shared understanding, candid feedback, assumptions, trade-offs, evidence, incidents, ADRs, decision context
4.9 The architect’s role in evolutionary systems
This section explains how architects use experience and feedback to guide adaptable systems, while leadership shapes whether those systems have the conditions to evolve.
- Architectural stewardship of change: Explain how an architect supports a system’s ability to change while keeping it useful over time.
Why it matters: This frames architectural responsibility around keeping a system useful as conditions change. - Experience as risk signals: Explain how architects use experience and feedback when making present decisions about an uncertain future.
Why it matters: It gives architects a way to consider future risk without pretending to know exactly what will happen. - Leadership conditions for evolution: Describe how leadership decisions affect whether architectural advice can lead to an evolving system.
Why it matters: Architectural guidance needs organizational support to become effective change.
Key terms: evolving risk landscape, boundaries, long-term coherence, adaptability, experience, feedback, pattern recognition, plausible futures, leadership, ownership
4.10 Summary
Concepts explained in this chapter
- evolvabilityEvolvability is the capacity of a software system or architecture to accommodate changing requirements, context, and implementation needs without disproportionate disruption or cost.
- architecture decision recordAn architectural record is a durable record of a significant architectural decision and its rationale or consequences.
- seamAn architectural seam is a deliberate boundary that allows part of a system to vary, be replaced, extended, tested, reconfigured, or modified with limited disruption to other parts.
- last responsible momentThe last responsible moment is the latest point at which a decision can be made while preserving sufficient time to act responsibly and avoid unacceptable consequences.
- replaceabilityReplaceability is the ability to substitute a system component or implementation without unacceptable effects on the rest of the system.
- feedbackFeedback is information from results, operation, stakeholders, or changing conditions that informs subsequent decisions and adaptations.
- soft architectureSoft architecture, or architectural softness, is an architecture designed to accommodate change, redirection, and component replacement without disproportionate effort or risk.
- continuous improvementA feedback loop is a recurring cycle in which information about results or changing conditions informs subsequent system decisions or adaptations.
- architectural preparationArchitectural preparation is the deliberate creation of limited structures, contracts, records, or tests that reduce the cost and risk of responding to plausible future changes.
- cost of waitingCost of waiting is the worsening delivery, financial, operational, or strategic impact caused by delaying an architectural decision.
- delivery riskDelivery risk is the possibility that an unresolved decision or delayed action will block progress, force workarounds, or create unsafe shortcuts.
- future changeFuture change is a later alteration in requirements, usage, technology, organization, or operating conditions that an architecture may need to accommodate.
- reversibilityReversibility is the degree to which an architectural decision can be changed or undone without disproportionate cost, risk, or disruption.
- architectural decayArchitectural drift is the gradual divergence of a system's implemented structure from the assumptions, boundaries, and qualities originally intended.
- architectural pressureArchitectural pressure is a force, constraint, or changing condition that influences software architecture and its decisions.
- constraintA limitation or condition, such as time, cost, capability, risk, ownership, law, or organization, that restricts architectural choices.
- overengineeringOverengineering is adding design complexity or capability beyond what current evidence and requirements justify.
- team capabilityTeam capability is the collective knowledge, skills, experience, and capacity available to design, build, operate, and sustain a system.
- responsibilityThe explicit accountability for maintaining architectural coherence, revisiting assumptions, and protecting important system qualities over time.
- architectural decisionAn architectural choice is a selected approach to a software system's technical structure or operation.
- event-driven architectureEvent-driven architecture is an architectural style in which components communicate and trigger work through events or messages.
- modular monolithA modular monolith is a deployable monolithic application organized into explicit internal modules with controlled boundaries.
- automated testingAn automated test is an executable check that evaluates software behavior without requiring manual execution of the check.
- time pressureDelivery pressure is the practical force created by deadlines, limited resources, changing requirements, and the need to produce working software.
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.
