Skip to main content
Discuss Book a call

The Field Report

Rising cost of change: why the third change costs more than the first

The first change took an afternoon. The second slid through. The third arrives with an estimate that makes the room go quiet, and nobody can say exactly why. That is the rising cost of change, and it has a cause you can find.

Author
Amit GovilFounder and CEO, XONIK
Published
October 22, 2026
Reading time
8 min read
In this piece
Download PDF

In brief

The rising cost of change comes from what each change leaves behind: a reader, a rule or an exception that the next change has to find out about before any work starts. That finding-out grows when nothing was recorded. Written reasons, tests, declared readers and scheduled removal flatten the climb.

Key findings

  1. Every change leaves residue that the system accepts without recording.

    A reader, a rule, an exception or a workaround. None is large, each was agreed to, and nothing records why. Left long enough, a workaround becomes a feature that a downstream team builds its routine on.

  2. An undeclared reader does the worst damage.

    Any output that is easy to read will be read by someone who didn't tell you. That hidden coupling raises the cost of changing the producer, even to improve it.

  3. The task stays the same size while the work of finding out what it touches grows.

    Each change has to avoid the residue of the last. Memory fades, and some residue belongs to people who've left. Unknowns get treated as risk, and that margin is what a sponsor sees when an estimate jumps.

  4. The usual protections add a fixed toll to every later change.

    Manual checks, reviews, freezes and bigger releases each answer a risk the team can feel. A check costs the same whatever the size of the change, and grouping makes each release harder to reason about.

  5. Declared readers, written reasons, tests and scheduled removal flatten the climb.

    Removal is the habit people skip, because it has no deadline and no sponsor, and it pays back best. Declare the coupling you have, since declared coupling can be planned for.

Where does the rising cost of change come from?

Every change solves a problem a team has in front of it, by the quickest route that's safe that day. The route leaves residue. Sometimes it's a reader: another report, job or partner now depends on a field the change touched. Sometimes it's a rule, such as orders from one channel being treated differently. Sometimes it's an exception for one account, for reasons that were good at the time. And sometimes it's a workaround, a manual step added until the proper fix arrives, which stays because the fix never does. None of it is large, and every piece was agreed to. What they share is that the system takes them in without recording them. The code runs, the report reads, and nowhere does anything say why.

The reader does the worst damage. A paper by Google engineers on hidden technical debt in machine learning systems (Sculley and colleagues, 2015) describes undeclared consumers: systems that silently use another system's output as their input. The authors say this creates a hidden tight coupling that can radically increase the cost and difficulty of making any change to the producer, even an improvement, and they link it to what classical software engineering calls visibility debt. The paper is about machine learning. In our delivery work the same mechanism turns up in ordinary systems, because any output that is easy to read will be read by someone who didn't tell you.

Residue also sets hard. A workaround that stays long enough becomes a feature. A downstream team builds its month-end routine around the manual step, and when someone later removes it, a process breaks that nobody on the changing team knew existed. The longer a leftover lives, the more of the business stands on it, and the more a clean-up looks like a change in its own right.

Why does each change cost more than the last?

The change itself stays about the same size. What grows is the work of finding out what it touches. The first change meets a system with nothing left behind. The second has to avoid the first one's residue, and the team still remembers it. The third has to account for both sets, and one set has started to fade from memory. By the fourth, some of the residue belongs to people who have left. The diagram below draws the stair. Effort rises as the question "what else uses this?" loses its answer on paper.

Further effects steepen the stair beyond a simple sum. Residue interacts: a rule for one channel and an exception for one account meet in the case of that account on that channel, and every new item can meet every old one, so interactions multiply faster than the items do. And each unknown has to be treated as a risk, so the estimate carries a margin for what nobody can see, wider where less is written down. That margin is what a sponsor sees when the estimate jumps and nobody can say why.

D. L. Parnas made the same point in 1972 with a small indexing example. In one way of dividing the system, a change to how lines were stored forced changes in every module. In another, each module hid one design decision from the others, and the same change stayed inside a single module (On the Criteria To Be Used in Decomposing Systems into Modules, Communications of the ACM, December 1972). The cost of a change follows the number of places that know about the decision being changed.

What the next engineer has to find out

A rising stair of changes, from the first, with nothing to find out, to the last, with leftovers no one can name, and a break where memory runs out after the second.
Each step's height is how much has to be discovered before the task can begin.
Read this as text

A stair of steps rising left to right. The first change: nothing to find out. The second change: the last change is still remembered. These are drawn in blue. A terracotta mark sits at the top of the second step, labeled where memory runs out, with the note that finding out becomes the work. The third change: older leftovers, less known. The fourth change: leftovers no one can name. The area from the mark onward is shaded.

Do the usual protections help?

Teams respond sensibly. They add a manual check before release, a review by the person who knows the old behavior, a freeze near busy periods, and a habit of grouping changes into larger releases so the cost of checking is paid once. Each answers a risk the team can feel. Each also adds to the cost of every later change, because a check is a fixed toll whatever the size of the change, and grouping makes every release bigger and harder to reason about.

The diagram below shows the loop of change. A change leaves a leftover. The leftover isn't written down. The next change has to ask what else uses it. The answer is protection, which makes the next change slower and larger, which leaves more behind. The loop breaks at the step where the residue goes unrecorded, because everything after that follows from a question with no written answer.

The loop that raises the cost

A cycle of steps: a change is made, a leftover stays, the next change asks what else uses this, and protection is added, with the break after the leftover stays because it is never written down.
Protection treats the symptom of a missing answer, and the loop runs again with a heavier fixed cost on every change.
Read this as text

A loop of steps, clockwise. Change made, by the quickest safe route. Leftover stays: a reader or a rule. Next change asks what else uses this. Protection added: checks, approvals and bigger batches, which leads back to the next change. The arc from leftover to the next question is broken, marked in terracotta and labeled never written down, with the note that there is no written answer. The center reads the cost loop.

What does the cost of change look like at a retailer?

This is a composite from retail, not one client. A retailer's delivery rules start simply: a charge applies below an order value. The first change adds a waiver for loyalty members, made in the checkout. The second adds a marketplace channel that must never show the waiver, handled by a condition on the channel. The third request is a new offer for members who buy through the marketplace. Without reading the checkout code and asking finance, nobody can say what the waiver and the channel condition do together, which report reads the delivery charge, or whether the customer-service tool recalculates it. The developer spends the first days of the estimate answering those questions, and the answers live in people's heads and a spreadsheet. By the fourth request the team has stopped giving firm dates, and the business reads that as a slow team.

Had each change been recorded with its leftovers, the third estimate would have started from a short list and ended on a date. The list would have said that the finance report and the checkout both read the waiver, that the channel condition applies before the waiver, and that the marketplace feed ignores both. The code was the smaller part of that estimate.

What made the third change expensive was rebuilding what the earlier changes could have written down in an afternoon.

What flattens the climb?

Each of these habits is aimed at one kind of residue. Declare readers: an output others may use is published with a named owner and a list of who reads it, and access that isn't declared isn't given. The Google paper points the same way, saying undeclared consumers are hard to detect unless a system is designed to guard against them, for example with access restrictions or strict service-level agreements, since engineers will use the easiest signal at hand when a deadline presses. Write each rule where the next person will look, with its reason, in the same change that introduces it. Turn every rule and exception into a test, so the system itself states what it must still do and a change that breaks one fails before release. And retire things: give each exception an owner and a review date, and treat removing it as scheduled work.

Removal is the habit that gets skipped, because it has no deadline and no sponsor. It pays back best. The same paper lists deleting dead code and reducing dependencies among the ways to pay down debt, and says it is often beneficial to periodically reexamine each experimental branch to see what can come out. Each removal shrinks the set of things every later change has to consider.

This is a description of a mechanism seen in delivery work and in the papers cited. It measures nothing, and it doesn't say a system should never be coupled; some coupling is the purpose of a system. The case is for declaring coupling, because declared coupling can be planned for and undeclared coupling has to be discovered.

Sources read for this piece

Each paper was opened and read for the passages cited on 23 October 2026. The climb and the loop come from delivery work and are offered as a mechanism. Nothing is measured.

  1. D. Sculley and colleagues, Hidden Technical Debt in Machine Learning Systems, Advances in Neural Information Processing Systems 28, 2015: undeclared consumers, visibility debt, ways of paying down debt
  2. D. L. Parnas, On the Criteria To Be Used in Decomposing Systems into Modules, Communications of the ACM, volume 15, December 1972: effect of a change under different ways of dividing a system

Use this

On your next change, keep a running list of what the team had to find out before it could start. That list is the record the last change should have left behind.

Is an estimate on your desk climbing?

Tell us about the change whose estimate nobody can explain. A senior person reads it and replies with where we would look first.