Operational Debt Has an Interest Rate. Here's How to Price It.

Defer a two-day fix long enough and it turns into a two-week one. The same workaround that costs about $1,000 to close today costs roughly $18,000 to close in two years, because the org grows around it and every new report, flow, and rule takes a dependency on the broken thing. That multiplier is the interest rate nobody prints on operational debt, and it is the reason “we’ll clean that up later” is the most expensive sentence in ops.

A director once asked me to “clean up Salesforce when I got a chance.” That request had been sitting in a backlog for fourteen months. Nobody could say what cleaning up would cost, so it never beat a deal desk fire or a board slide for priority. Meanwhile an ops analyst spent four hours every Monday reconciling two owner fields that disagreed, a validation rule that fired on the wrong record type made reps route around it with junk data, and a reporting field nobody trusted got quietly excluded from the forecast. None of that showed up on a P&L. All of it was interest, compounding at a rate the org never chose to owe.

Operational debt behaves like financial debt. You take it on to ship faster, which is often the right call. The problem is that unlike a loan, nobody prints the rate on the workaround, so it compounds in the dark. Watch what deferral does to the price of a single fix, and you can see the whole trap in one line. Scroll it, then I will show you the model that prices it and the five-part build that pays it down.

1KNowa two-day before-save flow closes it

That curve is the argument. The workaround did not get worse on its own. The org grew around it, and each new thing that touched the broken field raised the cost to ever remove it. The fix that was a two-day build at inception is a two-week untangling by the time anyone measures it, so the payoff math that was obvious on day one looks daunting on day four hundred, and you defer again. The curve is built to trap you. The rest of this piece is how to get in front of it.

Debt is not the enemy. Unpriced debt is.

Taking on operational debt is often correct. You need the campaign live before the event, so you hardcode the region instead of building the routing rule. You need the report by Friday, so you paste a manual join instead of modeling the object. That is a loan against future ops time, and like any loan it can be the right financial decision. A shortcut that saves two weeks now and costs one hour a month is a good trade for a year or more.

Borrowing is fine. The failure is that the interest rate stays invisible. When you cannot state the weekly cost of a workaround, three things happen. You cannot compare fixing it against the next feature request, so it always loses. You cannot tell a good shortcut from a bad one, so you accumulate both. And you cannot see the compounding, so a workaround that cost one hour a month at inception is quietly costing six by the time anyone measures it, because three more workarounds now depend on it.

The interest-rate model

Every piece of operational debt has three inputs: the recurring time it burns, the fully loaded cost of the person burning it, and the blast radius when it fails. Multiply the first two for the visible interest, then add the expected cost of failure for the true rate.

The formula I write on the whiteboard:

weekly interest = (hours per week × loaded hourly rate)
                + (failure probability per week × cost per failure)

annual interest = weekly interest × 52
payoff period   = one-time fix cost ÷ weekly interest

The loaded hourly rate is not the salary line. A GTM ops analyst on a $95K base costs roughly $130K fully loaded, which is about $65 an hour against 2,000 working hours. A four-hour weekly reconciliation is $260 a week of visible interest, $13,520 a year, before you count the forecast that misses because the owner field was wrong when the report ran.

The compounding curve is the part that gets you

Financial debt compounds because interest joins principal. Operational debt compounds because workarounds become dependencies. The manual join you built for one report gets copied into four more. The orphan field nobody cleaned up gets referenced by a flow, then a validation rule, then a dashboard, and now removing it breaks three things you forgot existed. Each new dependency raises two numbers at once: the weekly interest you pay to keep the workaround, and the one-time cost to ever remove it. The hero curve above tracks that second number. Here it is as a table, so the escalation is explicit and you can point to the line item that grew.

Months the fix sits unpaid	Cost to fix	What took a dependency on the broken thing
Now	$1,040	Nothing. A two-day before-save flow closes it.
6 months	$3,000	Two reports now read the mismatched field.
12 months	$7,000	A flow and a validation rule branch on the field.
14 months	$9,000	The same request that sat in the backlog, now load-bearing.
24 months	$18,000	A dashboard, a routing rule, and three reports all read it.

The fix crosses $9,000 at month 14, which is not a coincidence in the story: that is the exact backlog age of the “clean up Salesforce” request the director handed me. A $1,040 job, deferred until it depended on nine other things, had quietly become a $9,000 one, and it was still losing prioritization fights because nobody had put that number on it. This is why “we’ll fix it later” is the most expensive sentence in ops. Later, the fix costs more and the interest is higher, so the payoff math that was obvious at inception looks daunting, and you defer one more quarter.

A debt ledger, not a backlog

A backlog is a list of things you would like to do. A ledger is a list of debts with a balance. The difference matters because a backlog item competes on vibes and a ledger item competes on a number. I keep every piece of operational debt in a ledger with its priced interest, sorted by payoff period, and I review it the way finance reviews AR aging.

Here is the shape of a real ledger from an org I worked on, priced with the model above:

Debt item	Hours/wk	Failure cost/wk	Weekly interest	Fix cost	Payoff
Owner field reconciliation	4.0	$160	$420	$1,040	2.5 wks
Manual forecast join in sheet	3.0	$300	$495	$2,600	5.3 wks
123 overlapping active flows	2.0	$240	$370	$9,000	24 wks
Orphan required fields (41 of 47)	1.5	$180	$278	$1,600	5.8 wks
Stale territory rules	1.0	$90	$155	$3,200	20.6 wks

Sort by payoff period and the work orders itself. The owner field and the orphan fields are near-instant wins that free analyst time you immediately reinvest in the bigger items. The flow consolidation has a longer payoff but the highest absolute interest, so it earns a scheduled sprint rather than a “someday.” Nothing on this list is a matter of taste anymore. It is a schedule.

Two of these connect to full write-ups worth reading: the 47 required fields tax and the story of when we deactivated 123 flows and nothing broke. Both started as ledger entries exactly like these.

Find the debt before you can price it

You cannot ledger what you cannot see. Most operational debt hides in three places: fields nobody populates, automations that overlap, and reports built on manual steps. The first two you can query directly. Start with fields that exist but carry almost no data, the classic sign of an orphan requirement or an abandoned initiative.

SELECT QualifiedApiName, Label
FROM FieldDefinition
WHERE EntityDefinition.QualifiedApiName = 'Opportunity'
  AND DataType != 'Formula'
ORDER BY Label

That lists the field inventory. To find which of them are dead, sample populated rates against recent records. A field that is non-null on under 5% of the last year of opportunities is either niche or abandoned, and either way it belongs in the ledger for a decision:

SELECT COUNT(Id) total,
       COUNT(Custom_Field__c) populated
FROM Opportunity
WHERE CreatedDate = LAST_N_DAYS:365

For automation debt, count active flows and triggers per object. When one object fires a dozen automations on the same event, you are paying interest in save-time, in ordering bugs, and in the fear that stops anyone from touching it:

SELECT TriggerType, COUNT(Id)
FROM FlowDefinitionView
WHERE IsActive = true
GROUP BY TriggerType

Each row that comes back is a candidate for the ledger. Price it, sort it, schedule it.

Here’s how I’d build it: the debt-pricing operating system

This is the framework I install so debt stops being invisible. Five parts. The first three stand up in a week, the last two make it durable. Each one attacks a different point on the curve at the top of this piece: the earlier you catch a debt, the flatter its fix cost stays.

1. 1

   Set the loaded rate once

   Agree a single fully loaded hourly figure for ops time (base times ~1.4 divided by 2,000 hours). Get finance to bless it. Now every hour a workaround burns carries a dollar sign, and you never argue about the multiplier again.

2. 2

   Run the discovery queries

   Pull dead fields, overlapping automations, and manual report steps. Interview the analysts about their Monday-morning rituals, because the worst debt is the recurring manual task everyone has normalized and nobody logs.

3. 3

   Price each item into a ledger

   For every debt, record hours per week, failure probability and cost, weekly interest, one-time fix cost, and payoff period. Sort by payoff. This artifact replaces the backlog for ops debt.

4. 4

   Pay down shortest-payoff-first

   Work the top of the sorted ledger. Sub-four-week payoffs are near-arbitrage; do them immediately and reinvest the freed hours into the next tier. Reserve one scheduled sprint per quarter for the high-interest big fixes.

5. 5

   Gate new debt at the door

   When someone proposes a shortcut, price it before you ship it and log it in the ledger the same day with a review date. Good debt taken on knowingly is fine. Debt taken on invisibly is how you end up with 282 automations.

Before and after the ledger

The ledger does not change the work. It changes which work happens and why. Here is the same ops team, before and after they priced their debt.

	Backlog of chores	Priced debt ledger
How debt is described	"We should clean up the owner fields sometime"	$21,800/yr interest, 2.5-week payoff
How it competes for priority	Loses to every feature request	Sorts by payoff against everything else
New shortcuts	Added silently, forgotten	Priced and logged with a review date at the door
What the manager sees	A backlog that only grows	A balance that trends down, with interest saved
Analyst Mondays	4 hours reconciling two fields	Reinvested in the next ledger item

The invoice you are choosing to pay

Operational debt is real debt with a real rate. The only difference from a loan is that the bank does not mail you a statement, so you keep paying interest you never chose to owe, and the cost to clear the balance climbs every quarter you look away. The fix is a spreadsheet: hours times loaded rate, plus failure cost, times fifty-two, divided into the cost to fix. Do that for the five worst workarounds in your org this week and you will find at least one yielding over 1,000% annually that has been losing prioritization fights for a year.

Pull the three discovery queries above, price your top five debts into a ledger, and walk into your next planning meeting with dated invoices instead of a wish list. The debt was always there. Now it has a rate, and once it has a rate, deferring it is a decision someone has to defend out loud.