liveBook · Manning

Blast radius

As explained in Grokking Software Architecture

A blast radius is the extent to which a software failure, defect, outage, misconfiguration, security breach, or regulatory scope affects other components or the surrounding organization.

A software failure can be a small spark or a grenade: the difference is how far its effects travel. Blast radius is the extent of a failure, defect, or misconfiguration’s impact. The same idea also helps assess how widely a change might force updates elsewhere. section 3.3.1

A large blast radius lets trouble in one component cascade into others; a small one contains the damage. Clear boundaries and fewer dependencies help limit that spread, making systems safer to change and more resilient. section 3.3.1 section 3.11

To assess the potential blast radius between a client and a service, ask:

  • Does the client make a few high-level calls, or orchestrate many low-level operations? section 3.3.1
  • Does it reach into nested service properties or repeat a sequence of calls that exposes the service’s workflow? section 3.3.1
  • If the service’s internal logic changes, how much client code would break and need updating? section 3.3.1

A playbook that is risky to edit

A method with a growing chain of play-specific conditions has a large change blast radius: a mistake in a new branch could break existing plays. Instead, a shared play contract lets the player accept new implementations without continually rewriting the core method. section 3.4.2

Listing 3.6 “After”: Following OCP - Extension
 
// new class for a dribble move
class DribblePastOpponent 
{
     execute()
     {
          console.log(“Executing a dribble move…”);
          // Dribbling logic here
     }
}
 
//new class for a defensive formation
class DefensiveFormation
{
     execute()
     {
          console.log(“Getting into defensive position…”);
          // Defensive logic here
     }
}
 
class Midfielder #A
{
     executePlay(play)
     {
      if (typeof play.execute !== 'function') { #B
             throw new Error("Play must implement an execute() method!");
          }
          play.execute();  
     }
}

Compare the separate play implementations with the player’s shared execute contract. section 3.4.2

Containing payment data

Payment logic sharing a monolith’s infrastructure can widen both the regulatory scope and the security impact of a breach. Isolating it in a payment service with a dedicated database and network boundary can narrow both. That isolation must be weighed against the overhead of microservices; a separate service alone should not be assumed to guarantee containment. section 12.4.4

How Grokking Software Architecture covers it

How deep it goes
Defines large and small blast radii and supplies a coupling checklist, without a numerical measurement method.
Examples
Illustrates blast radius with client-service calls, a conditional playbook, and isolated payment processing.
What you can do after
Evaluate how service dependencies and architectural boundaries affect the potential spread of changes and failures.
How it connects
Connects blast radius to loose coupling, the open/closed principle, and security isolation.

Also explained in

Compare how 8 books explain blast radius →

Related concepts

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