liveBook · Manning

Automated testing

As explained in Software Architecture Decision-Making

An automated test is an executable check that evaluates software behavior without requiring manual execution of the check.

Automated testing is an executable check of software behavior that trades delivery effort for faster, repeatable feedback. That trade is contextual: a one-off change may justify manual testing, while critical paths, dependency updates, and rollback-sensitive work warrant stronger safeguards. section 2.1 section 4.3

Treat automated testing as an explicit risk decision:

  • Use less automation when manual testing safely meets an immovable deadline and the change is limited. section 2.1
  • Protect high-consequence areas, including critical user paths, data integrity, deployment, rollback, and security-sensitive changes. section 2.1
  • Pair tests with observability and rollback plans when dependency or framework updates can alter runtime behavior, configuration, performance, or security. section 4.3
  • Make omissions visible by recording what was skipped, why, who owns the risk, and when the decision will be revisited. section 2.1
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 rigidity assessment to relate increasing testing effort, coordination, and regression cycles to architectural friction. section 4.3

How Software Architecture Decision-Making covers it

How deep it goes
Frames testing as a risk countermeasure and decision trade-off, but stops short of implementation techniques, test design, or tooling.
Examples
Uses one-off changes, critical user paths, dependency updates, package bumps, and framework upgrades as testing decisions.
What you can do after
Evaluate when automation is worth its delivery cost and identify risks that require tests, observability, rollback, or explicit ownership.
How it connects
Connects automated testing with time-to-market, technical debt, observability, rollback plans, dependency updates, and feedback loops.

Also explained in

Compare how 4 books explain automated testing →

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.