liveBook · Manning

Architectural decay

As explained in Software Architecture Decision-Making

Architectural drift is the gradual divergence of a system's implemented structure from the assumptions, boundaries, and qualities originally intended.

Architectural decay appears when a system stops absorbing change cleanly. Exceptions replace extensions, local decisions accumulate, and a once-stable structure begins behaving like legacy. No single symptom proves failure; the concern is a pattern of friction, workarounds, coordination, incidents, and growing infrastructure investment. section 4.3 section 1.2

Decay is driven by competing forces rather than by the absence of an architect title. Autonomous teams can preserve coherence when boundaries, interaction rules, and guardrails have explicit owners; freedom without accountability lets local choices erode system-wide assumptions. section 1.2

Treat recurring pain as architectural evidence when:

  • Developers repeatedly avoid the same module, service, or integration, skip refactoring, or accumulate long-lived TODOs. section 4.3
  • Small changes spread across unrelated modules or teams, producing broad pull requests, long regression cycles, or repeated coordination meetings. section 4.3
  • Workarounds, recurring production incidents, or rewrite discussions indicate that existing assumptions may no longer hold. section 4.3
Table 4.1 Architectural rigidity assessment
Signal
Severity
Evidence to look for
Owner
Next action
Developers report repeated friction in the same part of the system
Low if occasional, high if every change in that area becomes painful
Repeated complaints, long-lived TODOs, skipped refactoring, recurring delays
Team owning that module or service
Review the boundary, dependencies, tests, and ownership around that area
Small changes require increasing coordination or testing
Low if limited to one release, high if unrelated teams are repeatedly involved
Pull requests touching many modules, long regression cycles, release coordination meetings
Architect with affected teams
Identify why the change spreads and whether a seam, contract, or module boundary is missing
Developers hesitate to touch certain modules, services, or integrations
Medium if only one person avoids it, high if the whole team avoids it
“Only X knows this,” delayed fixes, fear of breaking production, lack of tests
Engineering lead or module owner
Create a recovery plan: improve tests, document behavior, add observability, and plan incremental cleanup
New features are implemented through workarounds or exception
Medium if temporary, high if workarounds become normal delivery practice
Feature flags used permanently, special-case code, manual operational steps, bypassed standards
Product and technical owner together
Decide whether the workaround should be removed, formalized, or treated as a signal that the architecture no longer fits
Rewrite discussions become more frequent
Medium if frustration-driven, high if linked to repeated delivery or incident pain
Repeated rewrite proposals, failed refactoring attempts, escalating maintenance cost
Architect and leadership
Separate emotion from evidence: identify the specific constraints, cost of change, and possible incremental replacement path

Use the architectural rigidity assessment to connect each signal to evidence, an owner, and a proportionate next action. section 4.3

How Software Architecture Decision-Making covers it

How deep it goes
Traces visible signals through feedback mechanisms to deferral, adaptation, or replacement, but stops short of a complete remediation procedure.
Examples
Uses repeated friction, spreading changes, avoided modules, workarounds, production incidents, and rewrite discussions as evidence.
What it assumes
Assumes familiarity with system boundaries and team decisions while making cross-cutting ownership and guardrails explicit.
What you can do after
Diagnose architectural rigidity by gathering team and operational signals, then revisiting assumptions and decisions.
How it connects
Connects architectural decay to feedback loops, observability, architectural reviews, ownership boundaries, and guardrails.

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Software Architecture Decision-Making. The section links point to the parts of the book it draws on.