Before You Refactor That Monolith, Thank a 1947 Warehouse Manager
Every engineer I know uses the phrase "technical debt" the way they use semicolons — automatically, without thinking about where it came from. So a few months ago I went down a rabbit hole, and the rabbit hole ended somewhere I did not expect: a warehouse modernization push in late-1940s America, decades before anyone had written a line of FORTRAN.
This is part origin story, part confession, and part experiment write-up. Bear with me, because the ending actually changed how I schedule refactors.
The Debt Metaphor Predates the Computer
Here's the thing about metaphors: they don't just describe decisions, they make decisions for you. Call something "debt" and your brain instantly reaches for a whole financial framework — interest, principal, minimum payments, credit scores. You never chose that framework. It came pre-installed.
The framing we inherited traces back to the postwar boom, when American manufacturers were frantically converting from wartime production and discovering that their warehouses — physical, dusty, full of forklifts — were the bottleneck. The management literature of that era is obsessed with a specific idea: deferring maintenance and modernization is a loan you take out against future throughput. The shelves sag, the aisles narrow, and eventually you pay back every deferred dollar with interest, usually at the worst possible moment.
Fast forward to 1986, when the software world got its own version of the idea in print, and then to Ward Cunningham, who famously tried to clarify that the metaphor was about writing code that fits your current understanding — not about writing sloppy code on purpose. Somewhere between the warehouse floor and the wiki, the metaphor got simplified into "we shipped it fast, we'll pay for it later," which is honestly the least interesting and most abused interpretation.
But the warehouse DNA is still there, hiding in plain sight. When a team says the monolith is "too heavy to move," they're talking about inventory. When they say a module is a "bottleneck," that's a shipping lane. We are all, whether we admit it or not, running software organizations using the physical intuitions of a 1947 logistics manager.
The Problem With Inherited Intuitions
The trouble is that financial metaphors smuggle in assumptions that don't hold for code.
Money has a fixed exchange rate. Code doesn't. Some "debt" sits in the codebase for a decade and costs approximately nothing — nobody touches that module, so the interest never accrues. Other debt compounds viciously: a bad abstraction at the center of your domain model taxes every single feature that flows through it.
If debt were real debt, we could compute an interest rate. So I decided to try.
The Experiment: Six Weeks, One Repo, Three Metaphors
I picked a side project of mine — a data-ingestion service with about 40,000 lines of Python that had grown the way side projects grow: organically and slightly embarrassingly. I catalogued 23 distinct "debt items," then sorted them by which metaphor justified the refactor:
- The Loan items — things we'd pay down because "debt accrues interest." Classic cleanup: upgrading dependencies, killing deprecated flags.
- The Warehouse items — things that slowed movement: the convoluted CI pipeline, the test suite that took 22 minutes, the on-call runbook that was a lie.
- The Structural items — things that were just wrong-shaped: one god-object that every feature had to pass through.
For six weeks I tracked hours spent versus measurable outcomes: deployment frequency, incident count, time-to-first-PR for a hypothetical newcomer (I actually had a friend do a cold-start exercise), and my own subjective misery, logged nightly on a scale of 1 to 5.
The Results Were Not What the Metaphor Predicted
The "loan" items — the ones the pure financial metaphor says to prioritize — performed the worst. I spent nine hours upgrading dependencies and modernizing config, and it moved basically none of my metrics. The code was no slower to change afterward. The metaphor told me it was accumulating interest; the measurements said the interest rate was roughly zero, because almost nothing in that code's blast radius was being modified.
The "warehouse" items crushed it. Cutting the test suite from 22 minutes to 6 (parallelization, plus deleting tests that tested nothing) cost me five hours and changed my behavior immediately — I started deploying three times as often, simply because the friction was gone. That's throughput, not balance-sheet math.
The structural item was the honest mixed bag. Carving the god-object into three modules took eleven hours, and six weeks later the measurable payoff is modest. But the cold-start exercise improved dramatically: my friend found the payment-handling code in 20 minutes instead of 90. Some debt only pays off when someone new walks through the building.
So What Do We Owe?
If I had to compress six weeks of note-taking into one sentence: stop asking "how much debt do we have?" and start asking "where is friction?" The financial metaphor is fine for communicating with management — it's the universal translator of corporate America — but it's a lousy prioritization tool, because it prices everything as if everything were touched equally often.
The warehouse managers of 1947, whatever their flaws, were measuring something real: how fast goods moved through the building. That's the part of the inheritance worth keeping. Debt is a story we tell about the past; throughput is a measurement we can take about the future.
My refactor backlog is now sorted by friction, not by shame. And the god-object? It's still half-refactored, and I've made peace with that. Some loans you just keep rolling.
The full tracking spreadsheet, plus the before/after CI numbers, are up in the repo linked below. Steal the methodology — it's one spreadsheet and a friend with a free Saturday.