Nothing Changes in Isolation: Every Software Change Has a Blast Radius

Ashrey Ignise

June 10, 2024

Nothing Changes in Isolation: Why Every Software Change Has a Blast Radius

Every Software Change Has a Blast Radius

“Can we just change this field?”

It is the kind of request that sounds trivial until someone who knows the system starts asking questions.

  • Who consumes the field?

  • Is it exposed through an API?

  • Does another service use it?

  • Do any tests assume the current behavior?

  • Is it tied to a reporting pipeline?

  • Does a customer integration depend on it?

  • Who owns those systems?

And, inevitably:

Is there anything else we're missing?

That last question is the dangerous one.

Because in a sufficiently complex software system, almost nothing changes in isolation.

Every meaningful change has a blast radius: the set of components, services, workflows, tests, requirements and people that could be affected by it.

The hard part isn't making the change.

It's knowing the blast radius before you do.


A “small” change rarely stays small

Imagine a product team decides to add a new payment method to checkout.

At the UI level, that sounds simple enough—add another option.

But follow the change through the system and the picture starts looking different.

FIGURE 01 — One product request, many possible dependencies




And even that diagram is probably incomplete.

  • Maybe the mobile application has its own checkout implementation.

  • Maybe an enterprise customer consumes the payment status through an API.

  • Maybe finance has reconciliation logic built around the existing payment types.

  • Maybe a compliance requirement affects which payment data can be stored.

  • Maybe somebody added a workaround three years ago because of a production incident and the only person who remembers why has since left the company.

The change itself hasn't become more complicated. Our understanding of what the change touches has.


This gets worse as software ages

When a product is young, understanding its architecture is usually easy.

There might be ten engineers. Someone can explain most of the system on a whiteboard.

Five years later, the same product might contain hundreds of services, thousands of dependencies and years of accumulated decisions.

  • Teams have been reorganized.

  • Services have been rewritten.

  • Some migrations finished. Others got halfway through.

  • New systems were introduced without fully removing the old ones.

  • Libraries were upgraded.

  • Customer-specific behavior was added.

  • People left.

  • Documentation drifted away from reality.

The resulting software still works. But nobody holds a complete picture of why it works.

This is where change gets expensive.

Not necessarily because writing the code is difficult, but because establishing confidence around the change becomes difficult.


The information exists. The connections usually don't.

Large engineering organizations aren't short on information. They have enormous amounts of it.

  • Code is in GitHub.

  • Work is in Jira.

  • Architecture is somewhere in Confluence.

  • Tests exist in their own repositories.

  • Production behavior is captured by observability systems.

  • Ownership may live in a service catalog.

Important decisions are buried across pull requests, Slack threads, meeting notes, and the memories of individual engineers.

The problem is fragmentation.

Suppose an engineer wants to change a function called:

calculateRefundAmount()

Searching the repository can tell them where that function is defined. Finding references may reveal where it is called.

But what the engineer really wants to know is something closer to:

If I change the behavior of this function, what could happen downstream?

That question crosses several layers of context.

FIGURE 02 — The information needed to understand one change




Each piece might already exist. But what is usually missing is the map connecting them.


Software is a graph, even if we don't manage it like one

Most software tools present information as containers—repositories, folders, tickets, documents, and projects.

Those are useful ways of storing things. But they are a poor representation of how the system actually behaves.

Software behaves much more like a graph.

  • A function calls another function.

  • A class implements an interface.

  • A service consumes an API.

  • A test verifies a behavior.

  • A requirement led to a feature.

  • A team owns a service.

The relationships are often more useful than the objects themselves.

Consider a simplified system:

FIGURE 03 — A dependency chain hidden behind a function




Looking at calculateRefundAmount() alone tells us very little.

Following the dependency chain tells us that changing it could eventually alter a customer-facing subscription workflow.

Now the engineer has something useful—not merely where the code is, but where the consequences might travel.

That is blast-radius analysis.


Direct dependencies aren't enough

Most engineering tools can help with immediate references. The harder problem begins two or three hops away.

Imagine this:




A developer modifying Function B may never touch the mobile application. There may not even be a direct dependency between them.

Yet a behavioral change at the bottom of that chain can still surface at the top.

This is why useful impact analysis can't stop at:

“Here are the references to this function.”

It has to ask:

“What depends on those references?”

And then:

“What depends on those?”

The result isn't a binary answer. It is a graph of possible impact.

Some relationships will be obvious and deterministic. Others will be weaker:

  • An import can be observed directly.

  • A function call can often be resolved.

  • A dependency inferred from naming or architecture may carry lower confidence.

That distinction matters.

A change-intelligence system should not pretend certainty where certainty doesn't exist.

It should show the engineer why it believes something is affected.


“High risk” is not an explanation

This is particularly important as AI enters engineering workflows.

A model can read a change and return:

Risk level: HIGH

That's easy.

But what is an engineer supposed to do with that?

A useful system should be able to say:




And then let the engineer inspect the evidence behind each relationship.

That is fundamentally different from asking an AI model to make a judgment from a large prompt.

The explanation is grounded in the system itself.


Underestimating blast radius causes failure

The obvious failure mode is missing something:

  1. An engineer changes a schema.

  2. A downstream consumer isn't identified.

  3. The deployment goes out.

  4. The consumer breaks.

Then the dependency becomes visible in the most expensive possible way: production.

This is how seemingly harmless changes become regressions, incidents, and outages.

But there is another failure mode that gets discussed much less.


Overestimating blast radius slows the entire organization down

When teams cannot confidently determine what a change affects, they compensate with process.

  • Add another reviewer.

  • Run the full regression suite.

  • Bring in architecture.

  • Ask the neighboring team.

  • Schedule another meeting.

  • Add an approval.

Eventually, enough people have looked at the change that everyone feels reasonably safe.

Sometimes that caution is warranted. Sometimes it exists because nobody can prove that the change isn't dangerous.

This is an important distinction.

Poor change visibility doesn't only create outages. It also creates bureaucracy.

FIGURE 04 — Two costs of not understanding change




Large organizations eventually get hit from both directions.

They move slowly, and things still break.


Better documentation helps. It isn't enough.

The obvious answer is:

Document the architecture better.

Teams should document their systems. But documentation has a structural problem when used as the primary source for impact analysis:

The software keeps changing.

  • Every merge can alter the dependency graph.

  • A new call is introduced.

  • An API consumer disappears.

  • A class begins implementing a different interface.

  • A service starts importing another module.

Unless someone updates the corresponding documentation every time the system changes, the map gradually diverges from the territory.

That is why we've become interested in a different starting point at Artus.

Instead of asking engineers to manually describe the entire system, how much of the system can we reconstruct from the evidence that already exists?

Code gives us a surprisingly rich starting point.

From a repository alone, static analysis can begin to identify things like:




That doesn't solve the whole problem.

It shouldn't be presented as if it does.

Runtime behavior, dynamic calls, infrastructure, external systems, and organizational context all introduce complexity beyond static source analysis.

But it gives us something extremely valuable:

a machine-generated technical map of the system grounded in evidence rather than memory.


Then the graph can become richer

Code is only the beginning.

Once a technical dependency graph exists, other context can eventually be connected to it.

FIGURE 05 — From code graph to change graph




Now a question like:

What happens if we change this?

can become much more interesting.

Not just—which functions depend on it?

But eventually:

  • Which APIs depend on it?

  • Which requirements does it support?

  • Which tests should be rerun?

  • Which teams own affected components?

  • Why was this behavior introduced?

  • Which customer workflows could be affected?

That is a very different way of approaching software change.


AI agents make this problem more important, not less

There is a strange imbalance emerging in software development.

We are getting dramatically better at making changes.

Coding agents can navigate repositories, write implementations, modify multiple files, generate tests, and open pull requests.

The cost of execution is dropping quickly.

But making a change quickly is not the same thing as understanding whether the change should be made.

Consider two agents given the same request:

Remove this deprecated endpoint.

The first agent does this:




The second does this:

FIGURE 06 — Execution agent vs change-aware agent




The second agent may actually write the same code. The difference is the context it had before doing so.

As agents become capable of making larger changes autonomously, this becomes a much bigger issue.

An agent capable of editing fifty files in thirty seconds is useful.

An agent capable of editing fifty files without understanding why those files exist is also dangerous.

The faster we make execution, the more important it becomes to understand consequences.


This is the problem we're working on at Artus

At Artus, we're starting with a narrow version of this problem:

Can we reconstruct enough of a software system's dependency graph to give an engineer a useful, explainable answer to: “If I change this, what else might be affected?”

That means mapping code entities and the relationships between them.

It means calculating downstream blast radius.

And importantly, it means showing why something appears in that blast radius rather than producing a black-box recommendation.

The long-term problem is considerably larger than code.

Software changes originate in requirements, architecture decisions, customer requests, regulation, and business decisions. But their consequences can eventually reach people, processes, and customers.

We think understanding those relationships will become its own layer of engineering infrastructure.

We call it Change Intelligence.


Before we change something, we should understand what it touches

For decades, enterprise software has become very good at recording things. But recording the pieces isn't the same as understanding how they fit together.

That distinction mattered when humans were making every change manually.

It matters considerably more when humans and AI agents can produce changes faster than ever before.

The goal isn't to eliminate complexity.

Complex systems are complex for a reason.

The goal is to make that complexity legible enough that, before someone changes something important, they can answer a deceptively simple question:

If we change this, what happens next?

Because nothing changes in isolation.

Background

Every change has consequences. Know them first.

Background

Every change has consequences. Know them first.

Background

Every change has consequences. Know them first.