Here’s an invented scenario. A finance chief at a mid-sized company asks why the Salesforce team needs a $185,000 cleanup budget when the CRM “works.” The admin lead answers that the org carries “a lot of technical debt.” The CFO asks what the interest rate is, and nobody can say. The request slips to next year, then the year after, and a retirement notice for an old automation type turns a planned project into an emergency. The debt was real. The pitch simply lacked a unit that finance recognizes, so it lost to every request that came with a figure.
This guide shows how to translate technical debt into principal, interest and payback, using public sources that all have a stake in the answer. Elements.cloud and Default are vendors that sell tools for finding debt. SonarQube documentation describes a code-quality product. Salesforce’s own policy pages are vendor material. Besker and colleagues wrote the peer-reviewed studies, though about general software, and a summary of the 2018 paper is hosted by a developer analytics vendor. I found no study measuring debt cost inside Salesforce orgs and no neutral benchmark for debt ratios. Every dollar figure in this guide is invented, so confirm with finance and Salesforce before presenting anything.
TL;DR
- Convert drag into dollars. Besker and colleagues report developer time wasted on debt at 23% in a 2018 survey of 43 developers and 36% in a 2017 survey of 258 participants, and both are self-estimates from general software work. On an invented team of 8 costing $1,120,000 a year, that’s $257,600 to $403,200 of drag.
- Show principal, interest and payback. Principal is the cost to fix, and interest is the yearly drag. On invented numbers, $185,250 of remediation pays back in 1.8 years if it recovers 40% of a 23% drag, and it loses money over 3 years at a 10% drag.
- Anchor the case to dates. Salesforce ended support for Workflow Rules and Process Builder after December 31, 2025, and its API policy lists versions 31.0 through 40.0 as deprecated from Summer ’27. Dated events let a CFO price the cost of waiting. Confirm every figure with Salesforce and with finance.
Why finance doesn’t accept the phrase technical debt
The phrase has no unit, and finance teams approve spending against a return, a risk or an obligation. Default’s guide, written by its Head of Growth, defines technical debt as the buildup of inefficiencies from quick fixes, rushed customizations and outdated configurations. I read the page and found qualitative claims only, with no cost figures in the body. A CFO can’t budget against “inefficiencies” because nothing in that sentence says how large they get or what happens if they’re ignored.
Borrow the finance meaning instead. Debt in a balance sheet has a principal, an interest rate and a maturity date. Technical debt maps onto those terms cleanly: the principal is the cost to fix the problem, the interest is the recurring extra cost of working around it, and the maturity is any dated event after which deferral stops being an option. This guide builds each piece with arithmetic a finance analyst can rerun, and it labels which inputs come from research and which are invented placeholders.
Not every shortcut deserves repayment. Default’s FAQ describes “good” technical debt as a deliberate trade-off made to ship faster, with a plan to refactor later. Finance already accepts borrowing for speed when the terms are known, so the pitch should separate deliberate shortcuts that are on schedule from accidental ones that nobody planned. Ask for money only against the second group, and say plainly that the first group is a managed decision, not a failure.
The numbers a finance team will actually check
Drag. Drag is the share of the team’s paid time that goes to working around old decisions instead of delivering new work. It’s the closest thing to an interest payment, and finance can multiply it by a loaded labor rate. Research gives a range, not a fact, and the range rests on self-estimates. The honest approach is to present a low case, a middle case and a high case, then let the reader see how the conclusion changes across them.
Principal. Principal is the effort needed to remove the debt, multiplied by a rate. SonarQube’s documentation defines technical debt as the sum of the remediation effort for each flagged issue, measured in minutes. That’s a code-scanning idea, so declarative metadata needs a parallel method, such as counting items by severity and assigning a review time to each. Whatever method you pick, write down the hours and the rate so an analyst can change either input.
Dated exposure. Dated exposure covers events that force work regardless of budget, such as a vendor ending support for a feature or retiring an API version. These are the strongest arguments because they don’t depend on a productivity estimate. Salesforce publishes some of these dates itself, and a later section lists the ones I found. A CFO who sees a date and a cost of waiting can compare the request against any other obligation on the calendar.
What counts as debt in an org and what doesn’t
- Unused or redundant metadata. Elements.cloud’s technical debt dashboard counts inactive metadata across about 20 types, including flows, reports, validation rules and email templates, and it groups reports by last run date. Unused items carry a small cost each, because every change requires someone to check whether the item matters. That cost is real, but it’s usually the smallest line in the pitch, so don’t lead with it. Treat it as housekeeping with a modest price tag.
- Outdated automation. The same dashboard rates workflow rules, process builders and active metadata on API versions below 47 as its most severe band. Automation built on retiring technology carries a dated risk as well as a drag, which makes it the best candidate for funding. Flows, Apex classes and triggers, Visualforce pages and Aura bundles don’t upgrade automatically with org upgrades, according to the dashboard article, so age accumulates silently.
- Packages and integrations. Elements.cloud states that its dashboard doesn’t include insights from managed packages. Debt inside a package or an integration therefore needs a separate inventory, and the owner is often a vendor. List these items in the pitch with a note that the numbers come from a different source, so the reader doesn’t assume the dashboard counted them. Ask each vendor what its own roadmap says about retiring features, because that answer affects timing.
- What doesn’t count? A missing feature, an unpopular screen and a backlog of enhancement requests aren’t debt. Default’s definition ties debt to shortcuts and outdated configurations, which means a past decision created it. If nobody chose a trade-off, the item belongs in the product backlog, and mixing them inflates the total and weakens the argument with a skeptical reader. Keeping them apart also protects the credibility of every number that follows in the pitch.
A severity scale for metadata
Elements.cloud’s dashboard sorts flagged metadata into 5 bands using rule matching, not a numeric formula. The vendor’s own help article, dated July 1, 2026, defines the rules, and I’m treating its thresholds as a vendor’s judgment call, not an empirically derived standard. The finance treatment column in the table below is my suggestion. It shows how a severity band could translate into a funding decision, and you should adjust it to your own risk appetite and planning calendar.
| Band | Elements.cloud rule (paraphrased) | Suggested finance treatment |
| Extreme | Workflow rules, process builders and active metadata on API versions below 47 | Fund now, with an owner and a date |
| Severe | Active automations on API versions 47 and 48 | Fund this fiscal year |
| High | Active automations on versions 49 to 51, and reports last run over a year ago | Schedule in the annual plan |
| Moderate | Low-impact fields, custom profiles, any inactive metadata, and automations on versions 52 to 54 | Clean up during related work |
| Acceptable | Active metadata on versions 55 to 57 | No action |
A scale like this gives the CFO a way to see that the request isn’t a single lump. Most of the cost sits in the top bands, where a rule-based reason exists, and the bottom bands can be handled as part of routine changes at no separate charge. Present the counts by band rather than a single total, and keep the screenshot from the tool in the appendix, because the dashboard article doesn’t publish sample values and I couldn’t verify any real counts.
Convert developer drag into dollars
Start with a loaded annual cost for the people who build and maintain the org. In an invented example, a team of 8 at $140,000 each costs $1,120,000 a year. Applying a 23% drag, the figure from the 2018 Besker study, gives $257,600 a year, or about $21,467 a month. The high case of 36% from the 2017 study gives $403,200, and my own low case of 10% gives $112,000. The low case is an assumption for stress testing, not a research finding.
Dollars are persuasive, but hours are easier to verify. A 23% share of a 2,080-hour work year is roughly 478 hours per person, or about 3,827 hours across the team of 8. A finance analyst can compare that number with ticket history and timesheets, and a gap between them is itself a finding. If the ticket system shows far fewer hours spent on rework than the research suggests, use the lower figure and say why.
Applying a general software percentage to a mixed team of admins and developers is a stretch. The studies surveyed software practitioners, and declarative work may behave differently. Besker and colleagues’ 2018 paper also examined the benefits of tracking and communicating wasted time to developers and managers, which supports the practical advice: tag tickets for a quarter, count the hours, and replace the research percentage with your own measurement before the final presentation. Whatever the source, show the arithmetic beside the answer so an analyst can reproduce it without asking.
Why the research percentages need a warning label
- Conflicting answers. Besker, Martini and Bosch’s 2017 paper reports that 36% of development time is estimated to be wasted, based on a web survey of 258 participants plus interviews with 32 practitioners. Their 2018 paper reports an average of 23% from 43 developers, with 16 follow-up interviews. A careful CFO will notice the gap, so present both and say that you chose a middle path. Show both and explain your choice in a sentence.
- Estimates, not measurements. The Chalmers summary of the 2017 paper says the 36% figure rests on practitioners’ estimates of their own time, not direct time tracking. People may over- or under-state the share, and I can’t tell which way the error runs. Label the figure as perceived waste, and avoid describing it as measured loss. The caveat limits how firmly the figure should be stated to the people who control the budget.
- General software, not Salesforce. I found no study that measured debt cost in Salesforce orgs. Much Salesforce work is configuration, which may carry less drag per hour than custom code, or more when automation collides. Neither direction is established, so the pitch should present the range as an outside reference and then replace it with local data. A local measurement settles the question faster than any debate about which study applies here.
- Host bias. The page that summarizes the 2018 study belongs to DX, a developer experience company that sells analytics, so it doubles as marketing. The underlying paper appears in the ACM Digital Library, and a careful analyst should read it there. A related caution applies to the 2017 summary, which I read only as a repository abstract, not the full paper. Cite the paper itself in the appendix so the reader can check the claim directly.
Principal, interest and the payback period
Principal. SonarQube’s metric definitions give a useful template for turning remediation effort into a ratio. The technical debt ratio equals the debt divided by the cost to develop a single line of code times the number of lines, with a default of 30 minutes per line. Ratings run from A at 5% or less up to E at 50% or more. In an invented example, 60,000 lines of Apex imply 30,000 development hours. Debt of 1,950 hours gives a 6.5% ratio, a B rating, and a principal of $185,250 at $95 an hour.
Interest. Interest is the yearly drag, and it’s what makes delay expensive. On the invented team, a 23% drag costs $257,600 a year. Remediation won’t remove all of it, so assume that fixing the debt recovers some fraction. I used 40% as an invented placeholder, which recovers $103,040 a year. That recovery figure is the number to defend in the meeting, because it connects the cleanup to a specific saving instead of a vague feeling of improvement.
Payback. Payback is the principal divided by the annual recovery. Here that’s $185,250 divided by $103,040, or about 1.8 years, which is roughly 21.6 months. Finance teams usually want a threshold in mind, and I don’t know yours, so ask the controller what payback period projects need to clear. The SonarQube scale is built around code lines, so declarative metadata should treat the ratio as a rough analogy and rely on hours and dollars instead.
Payback under 3 drag scenarios
A single scenario invites the objection that you picked the number you needed. The table below holds every input constant except the drag share, using the invented team of $1,120,000 in annual cost, a principal of $185,250 and a 40% recovery rate. The last column discounts 3 years of recovered savings at 10% and subtracts the principal. All figures are invented placeholders, so replace each with local data and ask finance to confirm the discount rate.
| Drag share | Annual drag | Recovered at 40% | Payback | 3-year net value at 10% |
| 10% (assumed low case) | $112,000 | $44,800 | 4.1 years | Loss of $73,839 |
| 23% (2018 study) | $257,600 | $103,040 | 1.8 years | Gain of $70,995 |
| 36% (2017 study) | $403,200 | $161,280 | 1.1 years | Gain of $215,829 |
The low case matters most, because it shows the project losing money over 3 years on productivity alone. That result is useful. It tells the CFO you aren’t selling a guaranteed return, and it points to the other arguments: dated exposure and risk. If your own measurement lands near the low case, ask for funding only for the items that carry a deadline or a risk, and handle the rest during normal changes.
Dates that turn debt into a deadline
SalesforceBen’s article says Workflow Rules and Process Builder “will no longer be supported after December 31, 2025,” which means users can’t get support and bugs won’t be fixed. The article is undated and has no named author. It doesn’t say whether existing automations stop running, and I found no confirmation of what changed after that date. As of October 26, 2026, the date is 299 days behind us, so any org still running these tools is already operating without vendor fixes.
Salesforce’s API end-of-life policy, read for the Metadata API, commits to supporting each version for a minimum of 3 years from first release and giving at least 1 year of notice before support ends. Versions 21.0 through 30.0 were retired as of Summer ’25. Versions 31.0 through 40.0 are deprecated and unsupported from Summer ’27 and retired from Summer ’28. Of 38 supported versions, 10 are on that path, or about 26%. Calls to retired versions fail, with a 410 code in REST and an UNSUPPORTED_API_VERSION error in SOAP. Salesforce’s policy page points to the API Total Usage event type for finding traffic that still uses old versions.
Dated events convert directly into a cost of waiting. In an invented example, migrating 60 old processes at 6 hours each takes 360 hours, or $34,200 at $95 an hour when planned. If the same work is rushed with an assumed 1.5 times premium for overtime and contractor rates, it costs $51,300, which is $17,100 more. The premium is my placeholder, not a published figure. Use a real quote from your delivery team, and confirm the retirement dates with Salesforce before relying on them.
Pricing the risk of doing nothing
Expected loss. Risk is a probability times an impact, and finance teams know the arithmetic. In an invented example, a 15% yearly chance of an upgrade-related outage that costs $50,000 gives an expected loss of $7,500 a year. Both inputs are guesses, so show the sensitivity: change the probability to 5% and 30% and see what the CFO thinks. Small expected losses may fall short of justifying a project alone, yet they strengthen a case that already has other support. Record the assumptions beside the result so they can be challenged.
Deferral cost. Waiting has a price, and it’s the recoverable interest you forgo. On the invented numbers, each year of delay gives up $103,040 of recoverable drag, which is more than half the principal. Put that sentence in the summary, because it reframes the decision. The question stops being whether to spend $185,250 and becomes whether to keep paying roughly $257,600 a year in drag to avoid doing so. Say it aloud in the meeting.
Compounding. Besker and colleagues’ 2018 paper found that developers are frequently forced to introduce new debt because of existing debt. That suggests the problem grows when ignored, but I found no published growth rate, and I wouldn’t invent a rate. Describe compounding qualitatively, and invite the team to track how many new workarounds were added each quarter, since that count gives a local estimate of how fast the interest rises. Keep the claim modest.
Evidence to collect before the finance meeting
- Time tags on tickets. For a full quarter, label each ticket with a reason code such as new work, rework from old design, or incident. At the end, the share tagged as rework gives you a local drag figure that replaces the research percentage. Even a rough tag applied consistently by every team member is stronger than a precise estimate from outside, because it comes from your own queue. Keep the codes few.
- A metadata inventory. Pull counts of inactive items by type, reports by last run date and automations by API version, which are the views the Elements.cloud dashboard describes. Keep the export dated and attach it to the pitch. The metadata inventory sets the size of the principal, and it also shows the CFO that someone looked at the actual org instead of repeating a general complaint. Refresh the export before every review meeting.
- Loaded labor rates from finance. Ask finance for the fully loaded hourly cost of employees and contractors instead of using salary alone. The difference can be large, and an analyst who supplies the number will own it in the meeting. It also prevents the common objection that your rate is too high or too low, because the rate came from the same department. Agreeing on the rate early removes a common argument from the room.
- Incident and change history. Default’s guide recommends monitoring performance, automation errors and API usage. Gather the last 12 months of outages, failed deployments and urgent fixes, with hours and business impact where known. A short table of real incidents carries more weight than a probability estimate, and it gives the risk section something concrete to stand on. Pair the list with the dates each item was fixed, so the pitch shows which problems recur.
Choosing between pay down, contain and accept
Not every item deserves repayment, and the CFO will trust a proposal that says so. The table below sorts the response options by cost profile. Each organization’s threshold will differ, so treat the middle column as a starting rule, and ask the delivery lead to assign every inventory item to a row. The sort itself is a useful exercise because it forces a decision on items that would otherwise sit in limbo forever.
| Option | When it fits | Cost profile | What to tell finance |
| Pay down now | Dated deadline or high-severity automation | Single project spend | Fixed scope, fixed date, named owner |
| Pay down on a schedule | Real drag with no deadline | Spread across quarters | Recovery grows as items close |
| Contain | Debt in packages or stable integrations | Small monitoring cost | Risk is watched, not removed |
| Accept | Low-impact items with little change activity | None | Deliberate choice, reviewed yearly |
The accept row builds credibility. It shows that the team decided what not to fix, which is a form of discipline finance appreciates, and it caps the total request. Review accepted items yearly, because a quiet field can become a problem when a new project touches it. If an item moves between rows, record the reason, so the next planning cycle doesn’t repeat the debate from scratch. It also gives reviewers a reason to trust the rest.
How to present it without jargon
Lead with the unit. Open with dollars per year and years to payback, not with the word debt. A sentence such as “we lose an estimated $257,600 a year to rework and can recover about $103,040 of it for a fixed cost of $185,250” gives a finance reader something to test. Save the technical vocabulary for the appendix, where the metadata counts and the API versions can sit beside the arithmetic.
Show the range. Present the low, middle and high cases together, as in the payback table, and say which case you believe. A range signals that you understand the uncertainty, while a single number invites an argument about whether it’s right. If the low case loses money, say so, then explain why the dated exposure and the risk justify the request anyway. Lead with the case you believe, then show the others beside it.
State the assumptions. List each input, its source and its owner: the labor rate from finance, the drag share from your own ticket tags, the recovery rate from the delivery lead. Mark which inputs are research-based and which are estimates. Analysts will change some of them in the meeting, and a model that updates cleanly looks more trustworthy than a polished slide with hidden assumptions. Keep the list on the same page as the totals.
Name the decision. End with a specific request: approve a fixed amount, for a defined scope, by a stated date, with a named owner and a review point. Finance can say yes or no to that. “Support our cleanup efforts” gives them no way to respond, and it leaves the team without a number to report against at the next quarterly review. Add a date for the first review so the outcome gets reported.
Funding models and where the money comes from
A single project budget fits best when the work has a dated deadline and a clear scope. The request is easy to evaluate, it has a start and an end, and the result can be measured against the payback promised. The risk is that projects end, the org keeps changing, and new debt accumulates afterward. A cleanup project without a prevention plan is a loan refinanced at the same terms, which finance will recognize as a repeat request. Pair the project with a short governance rule so new work doesn’t recreate the problem.
A standing allocation of team capacity suits drag that arrives continuously. Reserving a fixed share of each cycle for debt work keeps the interest from compounding, and it avoids the annual fight for a lump sum. I found no reliable published benchmark for the right share, so choose a number from your own measured rework and review it every quarter. Document what the reserved time delivered, otherwise the allocation will look like slack at the next budget review.
Chargeback to the business units that benefit is a third route, and it makes the cost visible where decisions are made. It also creates friction, because units may dispute the allocation. Whether remediation spend can be capitalized or must be expensed is an accounting question that I didn’t research, so ask the controller before the meeting. The answer changes how the cost appears in the budget, and it can change whether the request competes with operating spend or with capital projects.
A single-page summary a CFO can approve
Everything above fits on a single page if the table carries the numbers and the text carries the decision. The table below uses the invented figures from this guide to show the layout. Each row names its source, so a reader knows which lines came from research, which came from finance and which are placeholders. Replace every invented value with your own, add the dated events that apply to your org, and ask counsel or finance to confirm anything with legal or accounting weight.
| Line | Invented figure | Source of the number |
| Team annual cost | $1,120,000 | Finance (8 people at $140,000) |
| Drag share, middle case | 23% | 2018 Besker study, or local tags |
| Annual drag | $257,600 | Cost times drag share |
| Remediation principal | $185,250 | 1,950 hours at $95 |
| Recovery assumption | 40% | Delivery lead estimate |
| Annual recovery | $103,040 | Drag times recovery |
| Payback | 1.8 years | Principal divided by recovery |
| Dated exposure | $34,200 planned, $51,300 rushed | 60 processes, 6 hours each |
| Decision requested | Approve $185,250 with a review | Team and finance |
The page works because every number traces to a source and an owner. If the CFO challenges a line, you can name who supplied it and what would change it, without defending an opinion. Keep the single-page summary current, update it each quarter with your own tickets and inventory counts, and let the research percentages fade out as your local data replaces them. That traceability is what lets a busy executive approve it quickly.
FAQs
What’s technical debt in a Salesforce org?
It’s the accumulated cost of past shortcuts and outdated configuration that make current work slower or riskier. Default describes it as inefficiencies built up from quick fixes, rushed customizations and old settings, and its FAQ notes that some debt is a deliberate trade-off. Elements.cloud counts inactive metadata and automations on old API versions. A missing feature is a backlog item, not debt, because no past decision created it. Finance can price it once it’s measured.
How do I put a dollar figure on technical debt?
Split it into principal, interest and payback. Principal is the hours to fix the problem times at a loaded hourly rate. Interest is the yearly drag, calculated as team cost times the share of time lost to workarounds. Payback is principal divided by the yearly savings the fix recovers. Every input should have a named source, and I’d label invented placeholders clearly until your own tickets and finance data replace them. Show the arithmetic so an analyst can rerun it.
Which percentage should I use for developer time lost?
Use your own measurement if you can get it. Besker and colleagues report 23% in a 2018 survey of 43 developers and 36% in a 2017 survey of 258 participants, both self-estimates from general software work. I found no Salesforce-specific figure. Present a range with a low case below the research, say which case you believe, and explain how a quarter of ticket tags will replace the outside number. Replace it when local data arrives. Finance will respect a range that comes with a plan to narrow it.
What’s a good technical debt ratio?
SonarQube’s default scale rates a ratio of 5% or less as A and 50% or more as E, with 30 minutes of development cost per line of code assumed. That scale is built for scanned code, and I found no neutral benchmark for Salesforce orgs. Use the ratio as a rough analogy for custom code, and rely on hours and dollars for declarative metadata, then confirm your approach with finance.
Should I count unused fields as debt?
Yes, but as the smallest line in the case. Each unused item adds a little review time whenever someone changes related metadata, and Elements.cloud tracks inactive items across about 20 types. The cost per item is tiny, so a large inventory is needed before the total matters. Lead the pitch with automation on retiring technology and dated deadlines, and list the unused items as a tidy-up that rides along with other work.
What if the payback period is longer than the CFO’s threshold?
Say so, then change the request. In the invented low case, payback runs 4.1 years and the 3-year net value is a loss of $73,839, so productivity alone doesn’t justify the spend. Narrow the ask to items with deadlines or measurable risk, handle lower-priority items in routine changes, and ask the controller what threshold applies. A smaller, better-targeted request usually clears a threshold that a broad request misses. That keeps the request credible.
Do Workflow Rules and Process Builder still run?
I can’t confirm that. SalesforceBen’s undated article says they won’t be supported after December 31, 2025, so users can’t get support and bugs won’t be fixed, but it doesn’t say whether existing automations stop running. I found no later confirmation. Check Salesforce’s current documentation or your account team before you promise anything, and plan the migration to Flow as if support no longer exists. Treat it as an open question until Salesforce answers in writing.
Who should own the number?
Finance should own the labor rate and the discount rate, the delivery lead should own the hours and the recovery estimate, and the Salesforce owner should own the metadata inventory. Splitting ownership makes every input defensible, because the person who supplied it can explain it. A single presenter owning all of them invites a challenge. Write the owners next to each line in the summary, and review the model every quarter. Revisit the owners whenever the team changes.
