Soft architecture designs systems to accommodate changing requirements, technologies, teams, and constraints without disproportionate effort or risk. Its value appears in ordinary change: small requests remain containable instead of spreading through tightly coupled parts. section 4.10 section 4.5
Softness is not a ban on rewriting. It makes replacement deliberate, sliced, and controlled when requirements, scale assumptions, technology, or organizational understanding invalidate the existing model. section 4.5
Look for the forces that preserve or consume room for change:
- Preserve modularity, replaceability, extensibility, observability, and change isolation. section 4.10
- Prefer seams, stable contracts, backward-compatible evolution, and incremental replacement over disruptive all-at-once change. section 4.10
- Delay irreversible decisions until the last responsible moment, while using feedback loops to expose failing assumptions. section 4.10
- Challenge accidental complexity when it reflects premature guesses, fashionable patterns, or implementation habits rather than real problem complexity. section 4.5.2
An ordinary change request
An order-processing platform must add a fraud check before final payment. In a softer architecture, the change can usually remain contained; in a rigid one, tight coupling and fragile contracts spread its consequences. section 4.5
Table 4.2 Recognizing architectural softness in an existing system
|
Areas
|
Soft
architecture signal
|
Rigid
architecture signal
|
|
Change size
|
A small
requirement usually changes one clear area of the system
|
A small
requirement touches many unrelated modules, services, databases, or pipelines
|
|
Boundaries
|
Responsibilities
are clear enough that teams know where a change belongs
|
Teams argue
about where the change belongs or duplicate logic in several places
|
|
Contracts
|
APIs,
events, schemas, and interfaces can evolve through additive or versioned
change
|
Consumers
break when fields, timing, ordering, or undocumented behavior changes
|
|
Testing
|
The
affected area can be tested with focused tests and a manageable regression
scope
|
Every
change requires broad manual testing because nobody trusts the boundaries
|
|
Deployment
|
The changed
part can be released, rolled back, or disabled without moving the whole
system
|
Releases
require coordinated deployment of several unrelated components
|
|
Observability
|
The team
can see whether the change affected behavior, latency, errors, or downstream
consumers
|
The team
only discovers impact through incidents, user complaints, or support tickets
|
|
Ownership
|
A named
team owns the affected capability and can make decisions about it
|
Ownership
is spread across teams, or nobody knows who can safely approve the change
|
|
Replacement
|
A component
can be replaced behind a seam, contract, adapter, or routing point
|
Replacement
requires a big-bang migration because dependencies are tangled
|
Diagnose softness through change size, boundaries, contracts, testing, and deployment: manageable local change signals softness, while broad breakage and distrust signal rigidity. section 4.5
