liveBook · Manning

Soft architecture

As explained in Software Architecture Decision-Making

Soft architecture, or architectural softness, is an architecture designed to accommodate change, redirection, and component replacement without disproportionate effort or risk.

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

How Software Architecture Decision-Making covers it

How deep it goes
Diagnoses softness through ordinary changes, contracts, boundaries, testing, deployment, and complexity, stopping short of implementation instructions.
Examples
Uses an order-processing fraud-check change and a diagnostic contrasting soft and rigid change signals.
What you can do after
Evaluate ordinary changes, identify rigidity and accidental complexity, and guide incremental replacement with controlled risk.
How it connects
Connects modularity, replaceability, extensibility, observability, change isolation, stable contracts, backward compatibility, and feedback loops.

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.