RevOps · CRM architecture

CRM Technical Debt: Why Temporary Workarounds Become Permanent (And How to Fix It)

CRM technical debt rarely looks like bad code. It looks like a spreadsheet someone updates every Monday, a report that reads from it, and a commission calc nobody wants to touch. Here is how to find it, price it, and decide what to kill, build, or stop doing.

Joe LaGrutta, Founder of JayOhJoe LaGrutta, Founder, JayOh
12 min read · Updated October 2026
Always has been astronaut meme about CRM technical debt: Earth is labeled the temporary manual workaround, year 3, one astronaut asks wait, it is permanent, and the other replies always has been
Year three of a temporary fix. Sound familiar?
Joe LaGrutta, Founder of JayOhJoe LaGrutta, Founder, JayOh
The original LinkedIn post
Read the post +Hide the post -

The manual workaround is in year three. Nobody decided that. It just happened.

Here's how it goes.

A request comes in that the system doesn't handle cleanly. Building it properly takes a sprint and an uncomfortable conversation about whether it should exist at all. So someone opens a spreadsheet, does it by hand, and calls it temporary.

Three years later an ops person spends four hours every Monday on a process that exists because nobody wanted to have one difficult conversation.

The expensive part isn't the four hours. It's that the workaround grew dependencies. A report reads from it. A forecast assumes it. A commission calculation touches it. And the person who built it left eighteen months ago.

When we audit a revenue stack, we don't start with the tools. We start with the spreadsheets. Every manual step is a decision somebody avoided, and the cost compounds quietly while everyone optimizes somewhere else.

Some requests need a policy, not a workflow. Saying no once is cheaper than maintaining a yes forever.

Audit your spreadsheets. That's where your real process lives.

#RevOps #OperationsLeadership #SystemsThinking #GTM #ProcessDebt

Why this breaks

Nobody decides to keep a workaround. It just never gets un-decided.

The hours are the visible cost. The real cost is what quietly starts depending on the workaround, and who is left who understands it.

1

"Temporary" has no expiry date

The fix ships without an owner, a review date, or a named consumer. Nothing forces a decision, so the default decision is forever.

2

The right fix needs a hard conversation

Building it properly takes a sprint and a debate about whether the request should exist at all. A spreadsheet avoids both, so the spreadsheet wins.

The expensive one3

Dependencies grow in the dark

A report reads from it. A forecast assumes it. A commission calculation touches it. Now the workaround is load-bearing, and nobody drew it on the architecture diagram.

4

The builder leaves

The person who built it left eighteen months ago. Their logic lives in cell formulas and muscle memory. That is key-person risk sitting inside your revenue number.

5

Only net-new work gets funded

Every sprint goes to new requests. No capacity is reserved for paydown, so debt compounds faster than anyone retires it, while everyone optimizes somewhere else.

Researchers have a name for this: process debt, the gap between how work is supposed to flow and the workarounds people built to make it flow anyway. In a revenue stack it shows up as CRM technical debt and Salesforce technical debt layered on top of each other: the spreadsheet exists because the CRM couldn't do something, and the CRM never gets fixed because the spreadsheet covers for it.

What good looks like

Benchmarks for CRM technical debt

Strong teams don't have zero debt. They have a price on it, a fixed share of capacity paying it down, and nothing manual feeding the forecast.

MetricWeakAcceptableStrongSource
Sprint capacity reserved for debt paydownUnder 10%15–20%20–30%Apex Hours (2026)
Tech debt as share of the tech estateAbove 40%20–40%Under 20% (below ~10% rarely worth chasing)McKinsey (2023, citing 2020 CIO survey)
Rep time spent actually sellingUnder 30%30–40%40%+ (JayOh target)Salesforce State of Sales, via Landbase (2026)
Legacy Workflow Rules / Process Builder still runningBusiness-critical ones activeDated migration planZero activeSalesforce end of support after Dec 31, 2025
Manual hours per week feeding forecast, comp, or board numbers4+ hours1–3 hours, owned, with expiry0 hoursJayOh operating range
Surviving workarounds with a named owner + expiry dateUnder 50%50–90%100%JayOh operating range

Sources: Apex Hours, Salesforce Technical Debt (2026); McKinsey, Breaking technical debt's vicious cycle (2023); Salesforce State of Sales as reported by Landbase (2026); Salesforce end-of-support notice for Workflow Rules and Process Builder. Rows marked JayOh are our operating ranges from RevOps audits, not third-party benchmarks.

Why spreadsheets are the risk

In field audits compiled by spreadsheet-error researcher Raymond Panko, 49 of 54 operational spreadsheets (91%) contained errors (summary by Louise Pryor). Now picture one of those feeding your commission run.

Why it compounds

McKinsey found companies pay an extra 10–20% on top of every project to work around existing tech debt. Every new build that touches the workaround pays that tax again.

The playbook

How to pay down CRM technical debt in 8 steps

Start with the spreadsheets, not the tools. Inventory, trace, price, decide, then build only what deserves to exist.

1

Inventory every manual workaround

Why: your documented process and your real process are different documents. The real one lives in spreadsheets.

How: search Google Drive or SharePoint for file names containing pipeline, forecast, commission, FINAL, v2. Then ask every team lead one question: "What do you do by hand every week, and what reads it?" Log each answer as a row in the Workaround Register (template below).

2

Trace what depends on each one

Why: dependencies are where the cost lives. A sheet nobody reads is free to kill. A sheet the forecast reads is a production system.

Salesforce: Setup › Object Manager › [Object] › Fields and Relationships › [field] › Where is this used? for every custom field the workaround writes back to. Install the free Org Check app from Salesforce Labs to inventory unused fields, flows, and old API versions; it replaces Salesforce Optimizer, which was retired in the Winter '26 release.

HubSpot: open Settings › Properties › [property] and use the Monitor section: Usage shows where the property is used and its fill rate, and Data sources shows what writes it (HubSpot KB). For the sheet itself, list every report, dashboard, deck, and payout that pulls from it.

3

Price it in dollars, not hours

Why: "four hours on Monday" sounds small. $17,680 a year, and climbing, does not.

How: annual cost = hours per week × people × loaded hourly rate × 52. Then add risk: we add 15% per downstream dependency and 25% if the builder has left. That gives you a forward 3-year exposure you can rank by. The calculator below does the math.

4

Put every item in one of four lanes

Why: not every workaround deserves a workflow. Some deserve a "no."

KillNothing reads it. Archive read-only and stop.
PolicyThe request shouldn't exist, or the rules change every run. Decide once.
BuildRecurring, rule-based, feeds money or the board. Automate it natively.
KeepNeeds real judgment. Name an owner and an expiry date.
5

Write the policy for the "no" lane

Why: saying no once is cheaper than maintaining a yes forever.

How: one intake rule: no new manual process without an owner, a review date, and a named consumer of the output. Route requests through a form with acceptance criteria, like our marketing ops request intake template, so the uncomfortable conversation happens before the spreadsheet does.

6

Build the "build" lane natively, and simpler

Why: a 1:1 rebuild of a messy sheet just moves the debt into the CRM.

Salesforce: record-triggered Flows for real-time logic, scheduled Flows for the Monday batch, roll-up summary fields instead of manual totals, and custom report types instead of exports. Anything still on Workflow Rules or Process Builder goes through Setup › Process Automation › Migrate to Flow; support for both ended after December 31, 2025. Our Salesforce Flow audit covers the overlap check.

HubSpot: workflows for the recurring logic, calculation and rollup properties for the math, and the custom report builder for the output. Use the HubSpot audit framework to clear unused properties and dead workflows while you're in there.

7

Cut over with a parallel run

Why: if the new number doesn't match the old one, nobody will trust it, and the spreadsheet comes back.

How: build in a sandbox, run the old sheet and the new automation side by side for two full cycles, and reconcile to zero variance. Then set the sheet to view-only, rename it with an ARCHIVED prefix, and put a note in cell A1 pointing to the new source. Follow the rollout discipline in CRM change management so untested automation doesn't break revenue on day one.

8

Reserve capacity and measure the paydown

Why: a one-time cleanup regrows within a year. A standing budget doesn't.

How: reserve 20–30% of every sprint for paydown. Keep the register as an Asana project or a Salesforce custom object with fields for owner, expiry date, lane, and annual cost. Review it quarterly and track four numbers: hours retired per month, active workaround count, items past expiry, and the share of forecast and board numbers produced CRM-native.

Best practices and mistakes

What separates a cleanup from a paydown system

The best teams treat workarounds like debt on a balance sheet: priced, owned, and retired on a schedule.

Best practices

  • 01Start the audit with spreadsheets, not with the tool stack.
  • 02Price every workaround in dollars and 3-year exposure.
  • 03Count dependencies, not just hours. Dependencies drive risk.
  • 04Every surviving workaround gets a named owner and an expiry date.
  • 05Treat some requests as policy decisions, not build tickets.
  • 06Simplify before you automate. Cut steps, then build.
  • 07Retire fields in waves after confirming zero references in formulas, validation rules, flows, and code.
  • 08Parallel-run two cycles and reconcile to zero before cutover.
  • 09Archive, don't delete. Leave a pointer to the new source.
  • 10Reserve a fixed share of sprint capacity for paydown.
  • 11Document the rebuilt process where the next person will actually look.

Common mistakes

  • ×Automating a request that shouldn't exist.Cost: you now maintain a yes forever, in production.
  • ×Deleting a sheet before tracing its readers.Cost: a report or payout breaks at month-end close.
  • ×Rebuilding the spreadsheet 1:1 in Flow or workflows.Cost: the debt moves into the CRM and gets harder to see.
  • ×Skipping the parallel run.Cost: one mismatch and leadership goes back to the sheet.
  • ×Leaving Workflow Rules and Process Builder running.Cost: bugs no longer get fixed by Salesforce.
  • ×Running one big cleanup instead of a standing budget.Cost: the debt regrows within a year.
  • ×Letting the builder's logic leave with the builder.Cost: weeks of reverse-engineering a formula nobody owns.
Interactive tool · Calculator

Workaround Cost Calculator

Plug in one workaround. See what it costs per year, what it has cost so far, its 3-year exposure, and which lane it belongs in.

Annual cost-
Cost to date-
3-year exposure-
Build payback-
Recommended lane-

-

Math: annual = hours × people × rate × 52. Exposure = annual × 3 × risk, where risk adds 15% per dependency and 25% if the builder left (a JayOh planning heuristic, not a benchmark). Payback = build hours × rate divided by weekly cost.

Template + Claude skill

The Workaround Register

Copy this into a sheet, an Asana project, or a custom object. One row per workaround. If it isn't on the register, it doesn't get to exist.

WORKAROUND REGISTER  |  Owner: ________  |  Review cadence: quarterly

Columns
1. Workaround (what is done by hand)
2. Owner (named person, not a team)
3. Cadence and hours per week
4. People involved
5. Started (date) and original builder (still here? Y/N)
6. Downstream dependencies (reports, forecast, comp, board deck)
7. Annual cost (hours x people x rate x 52)
8. 3-year exposure (annual x 3 x risk)
9. Lane: KILL / POLICY / BUILD / KEEP
10. Native fix (Flow, workflow, rollup, report) or policy wording
11. Expiry or review date
12. Status: Traced / Priced / Decided / Parallel run / Retired

Lane rules
- KILL: nothing reads it. Archive read-only.
- POLICY: the request should not exist, or rules change every run.
- BUILD: recurring, rule-based, feeds money or the board, or payback under 26 weeks.
- KEEP: needs judgment. Owner and expiry date required.

Cutover checklist (BUILD lane)
[ ] Dependencies traced (Where is this used / property Usage)
[ ] Built in sandbox
[ ] Parallel run cycle 1 reconciled
[ ] Parallel run cycle 2 reconciled to zero variance
[ ] Sheet set to view-only, renamed ARCHIVED, pointer in A1
[ ] Process documented where the team looks
Free Claude skill

workaround-debt-auditor

Paste in your list of manual processes and Claude turns it into a priced Workaround Register using this post's framework.

  • Prices every workaround: annual cost, cost to date, and 3-year exposure with dependency risk.
  • Sorts each one into Kill, Policy, Build, or Keep, with the native Salesforce or HubSpot fix.
  • Quotes your input as evidence, never invents numbers, and lists what's missing.

Install it

  1. Claude web or desktop: open Settings › Capabilities, make sure code execution and file creation is on, then under Skills click Upload skill, choose the .zip, and toggle it on.
  2. Claude Code: save the file as ~/.claude/skills/workaround-debt-auditor/SKILL.md, or in .claude/skills/ in your repo.

Skills are available on Claude Pro, Max, Team and Enterprise plans. New to skills? Read how to use skills in Claude.

Preview SKILL.md
---
name: workaround-debt-auditor
description: Audits a revenue team's manual workarounds (spreadsheets, copy-paste jobs, side reports, one-off CRM fixes) and turns them into a priced Workaround Register with a Kill, Policy, Build or Keep decision for each item. Use when someone pastes a list of manual processes, spreadsheet names, ops notes or a CRM audit export and asks what their CRM technical debt or process debt is costing, what to fix first, or which workarounds to retire.
---

# Workaround Debt Auditor

You turn a messy list of manual workarounds into a priced, ranked register and a 90-day paydown plan. You apply the JayOh CRM technical debt framework: the cost of a workaround is not only its hours, it is the reports, forecasts and commission calculations that now depend on it, plus the risk that the person who built it has left.

## Inputs to ask for (only if missing)
1. The list of workarounds. One line each is fine: what is done by hand, how often, by whom.
2. For each item, if known: hours per week, number of people involved, what reads the output (reports, forecast, commission, board deck), whether the original builder is still at the company, and how long it has been running.
3. A loaded hourly cost for ops time. If none is given, use 85 USD per hour and say so in the assumptions.
4. The CRM in use (HubSpot, Salesforce or both).

Never invent hours, dependencies or costs. If a value is missing, mark it as unknown, leave it out of the math, and list it under Missing evidence.

## Step 1: Normalize each workaround
For every item record: name, owner, cadence, hours per week, people, years running, downstream dependencies (count and names), builder still here (yes, no, unknown). Quote the user's own words as evidence for each value.

## Step 2: Price it
- Annual labor cost = hours per week x people x loaded hourly cost x 52.
- Cost to date = annual labor cost x years running.
- Risk multiplier = 1 + 0.15 for each downstream dependency + 0.25 if the builder has left. This is a JayOh planning heuristic, label it that way.
- Forward 3-year exposure = annual labor cost x 3 x risk multiplier.
- If a build estimate in hours is given: build cost = build hours x loaded hourly cost, and payback in weeks = build cost divided by weekly labor cost.

## Step 3: Decide the lane
Apply these rules in order:
1. **Kill** when nothing reads the output (zero dependencies). Archive it read-only and stop doing it.
2. **Policy** when the work exists to satisfy a one-off or political request, or when the rules change every time it runs. The fix is a decision and an intake rule, not a workflow. Saying no once is cheaper than maintaining a yes forever.
3. **Build** when it is recurring, rule-based, and feeds forecast, commission, billing or board reporting, or when payback is 26 weeks or less.
4. **Keep** only when it needs human judgment. Every Keep gets a named owner and an expiry or review date.

## Step 4: Map the build
For each Build item, name the native tool:
- Salesforce: record-triggered or scheduled Flow, roll-up summary field, report type, Migrate to Flow for any remaining Workflow Rules or Process Builder (end of support after December 31, 2025). Use Where is this used on custom fields and Org Check to trace dependencies before changing anything.
- HubSpot: workflow, calculation or rollup property, custom report, data quality tools. Use the property Usage view to see where a property is used and its fill rate.
Then the cutover rule: build in a sandbox, run in parallel for two cycles, reconcile to zero variance, then make the old sheet read-only and archive it.

## Output format (always this structure)
1. **Headline**: total annual labor cost, total forward 3-year exposure, number of items per lane.
2. **Workaround Register**: a table with columns Workaround, Owner, Hours per week, Dependencies, Builder here, Annual cost, 3-year exposure, Lane, Evidence quote.
3. **Top 3 to fix first**: ranked by forward 3-year exposure, with the native build or the policy wording for each.
4. **90-day plan**: weeks 1 to 2 inventory and dependency trace, weeks 3 to 6 Kill and Policy items plus the first Build, weeks 7 to 12 remaining Builds with parallel runs. Reserve 20 to 30 percent of sprint capacity for paydown from then on.
5. **Missing evidence**: every unknown value and the question that would resolve it.
6. **Assumptions**: hourly rate used and any defaults.

## Guardrails
- Quote the input as evidence for every number. No quote, no number.
- Never invent stats, benchmarks, clients or dependencies.
- Do not recommend deleting anything that has an unknown dependency. Mark it Trace first.
- Keep the register in plain language a CFO could read.

Built by JayOh (jayoh.io). Framework and calculator: https://jayoh.io/crm-technical-debt/
FAQ

CRM technical debt: common questions

Short answers to what operators ask when they start pricing their workarounds.

What is CRM technical debt?

CRM technical debt is the future cost created by shortcuts in your CRM and the processes around it: unused fields, overlapping automations, legacy rules, and manual spreadsheet workarounds that compensate for what the CRM does not do. You pay it as extra hours, slower changes, and numbers leadership does not trust.

What is process debt, and how is it different from technical debt?

Technical debt lives in the system configuration. Process debt lives in how people work around the system: the Monday spreadsheet, the manual reconciliation, the copy-paste report. In revenue teams the two feed each other, because the workaround hides the gap the CRM never closed.

How do you find technical debt in Salesforce?

Install Org Check from Salesforce Labs to inventory unused fields, flows, and old API versions, use Where is this used on custom fields to trace references, and list every active Workflow Rule and Process Builder process for migration to Flow. Then add the spreadsheets that write back into Salesforce, because they are debt too.

How do you audit a HubSpot portal for unused properties and workflows?

Open each property in Settings and use the Monitor section: Usage shows where it is used and its fill rate, and Data sources shows what writes it. Review workflows with no recent enrollments, then confirm nothing in reports, lists, or integrations depends on an asset before you remove it.

How much sprint capacity should go to paying down technical debt?

Reserve 20 to 30 percent of each sprint for paydown. Below 20 percent, debt usually grows faster than you retire it. Above 30 percent, net-new work starts to starve. A standing budget beats a one-time cleanup.

When should a manual workaround be automated instead of replaced by a policy?

Automate it when it is recurring, rule-based, and feeds forecast, commission, billing, or board numbers, or when the build pays back in about six months. Replace it with a policy when the request should not exist or its rules change every time. Kill it when nothing reads the output.

What happens to Workflow Rules and Process Builder after December 31, 2025?

Salesforce ended support for Workflow Rules and Process Builder after December 31, 2025. They may keep running, but bugs are no longer fixed, so migrate business-critical ones to Flow using the Migrate to Flow tool and simplify them as you go.

The JayOh point of view

Audit your spreadsheets. That's where your real process lives.

When we audit a revenue stack, we don't start with the tools. We start with the spreadsheets, because every manual step is a decision somebody avoided. We trace what depends on each one, price it, and then do the unglamorous part: kill what nobody reads, write the policy for what shouldn't exist, and build the rest natively with a parallel run so the number holds.

If your forecast, comp, or board deck still runs through a file called FINAL_v7, that is the first thing we would fix.

90%fewer data errors (JayOh client result)
28%forecast-accuracy lift (JayOh client result)

Further reading: McKinsey on technical debt · Apex Hours on Salesforce technical debt · HubSpot property editor