Skip to content

Checklist

Technical debt triage checklist: what to fix now, schedule, or accept

Which technical debt do we fix now, and which can wait?

About software audits
Checks
42
Sections
7
Last updated

A technical debt triage checklist sorts the known shortcuts in a codebase by the harm they can do, so the dangerous ones get fixed first. This checklist scores each item for security, data, revenue, and delivery speed risk, prices the cost of waiting, and ends every item in one of three decisions: fix now, schedule, or accept.

The checklist is for founders, CTOs, and engineering leads at seed and Series A startups with a backlog of “tech debt” tickets nobody can rank. Use it when a new CTO inherits a codebase, when simple changes start taking days, before a fundraise or due diligence, or before committing budget to a rebuild. Taking on debt to launch was a reasonable trade, and this list shows which part to pay back first.

How do you use the technical debt triage checklist?

#
  • Work through it with someone who can read the code and open the hosting and database dashboards.
  • Answer each check yes or no. “I think so” counts as no, and so does a check nobody on the team can answer.
  • Write every no into your debt register as one item, tagged with the risk it carries: security, data, revenue, or speed. A no in the first section or the last two is a gap in the triage process itself, and it goes on the list too.
  • Give each item two rough numbers, its cost of delay and its fix size in days, then sort it with the guide at the end of this page.

Section 010 of 6 checked

How do you start a technical debt assessment?

  • Debt nobody wrote down cannot be ranked, so the loudest complaint wins the next sprint. Searching the code for TODO, FIXME, and HACK, and the issue tracker for words like “temporary”, finds items the team forgot.
  • An item that says “auth is messy” cannot be sized or closed. “Admin pages check the role only in the browser” can be scored, assigned, and verified once it is fixed.
  • Unowned items sit in the backlog until they cause an incident. The owner does not have to do the fix, but they keep the description and the estimate current.
  • Debt in code that changes every week taxes every feature, while debt in a file nobody touches costs almost nothing. git log --since='6 months ago' --format= --name-only | grep . | sort | uniq -c | sort -rn | head -20 lists the most-changed files. Skip lockfiles and generated code in the result.
  • An item tied to three incidents this quarter outranks a dozen that have caused none. Incident links turn opinions about code quality into evidence the whole team can see.
  • Some of the costliest debt never shows up in a code review, because people outside engineering absorb it. A support lead who edits rows by hand every Monday is paying interest on a missing admin action or a broken sync.

Section 020 of 6 checked

Could the debt expose data or accounts?

  • Published vulnerabilities are the easiest holes to find, because the advisory explains them. If a finding appears in CISA's Known Exploited Vulnerabilities catalog, which lists flaws exploited in the wild, it goes straight to fix now.
  • The Node.js end-of-life page states that a version past end of life no longer receives updates, including security patches. Every advisory published after that date stays open on your servers.
  • Checks copied into each route drift apart, and the route that was missed returns another customer's records to anyone who changes an ID. Broken access control ranks first in the OWASP Top 10:2025, so a known gap here is fix now even when the fix touches many files.
  • A boundary that lives only in the interface fails the first time someone calls the API directly. Adding one later touches most queries and tables, and the cost grows with every table built without it.
  • Deleting a key from the code leaves it in history, where anyone with a clone can recover it with git log -p. Rotation usually takes minutes and the exposure lasts until you do it, so this is always fix now.
  • Admin access held by people who no longer work with you is security debt that no code scan finds. It also blocks a clean answer when an enterprise security questionnaire asks who can reach production data.

Section 030 of 6 checked

Could the debt lose or corrupt data?

  • Until a restore works once, you do not know whether backups are usable or how long recovery takes. An untested backup is fix-now debt, because the loss it risks cannot be undone.
  • Changes clicked into a database console leave production with a schema nobody can rebuild from the repository, and the next generated migration can fail against it. In Postgres, diffing pg_dump --schema-only output from production against a fresh database built from migrations shows the drift.
  • Code that checks for a duplicate before inserting still lets two simultaneous requests create two accounts or two charges. Without constraints, bad rows pile up quietly, and every month adds more to clean before the next migration.
  • A sync that fails silently can leave the CRM, the billing system, and your database disagreeing for weeks. The longer it runs, the more records someone has to reconcile by hand.
  • Under GDPR and UK GDPR, people can in many cases ask for their personal data to be erased, and enterprise questionnaires ask how you do it. Personal data copied into logs and third-party tools is debt that grows with every new customer.
  • In JavaScript, 0.1 + 0.2 returns 0.30000000000000004, and rounding errors on invoices or payouts are hard to correct after customers have paid. The fix gets more expensive with every row and report that depends on the column.

Section 040 of 6 checked

Is the debt costing revenue or customers?

  • The same shortcut costs different amounts in different places. A slow query in an internal report annoys one person, while the same query on checkout loses orders.
  • Without an alert, a broken money path shows up as a customer email, often days later. An error tracker such as Sentry with alerts on those routes catches crashes, and an alert when completed signups or payments fall below their usual hourly count catches failures that throw no error.
  • Untested money paths make every nearby fix a gamble, so the team avoids the code and the debt stays. Five to ten Playwright tests there make later fixes safer to ship.
  • Debt that blocks a sale has a cost of delay you can name: the deal and its renewal. Put each gap on the register with the deals attached, so it competes on evidence rather than on who asks loudest.
  • A module that produces a bug report every week costs support time and customer trust, whatever its code looks like. Clusters show which debt to read first.
  • Averages hide the slow requests your largest customers feel, because they have the most data. The performance and scalability checklist covers how to find the queries behind them.

Section 050 of 6 checked

How much is the debt slowing delivery?

  • Setup that lives in one person's head costs days for every hire and contractor, and it stops anyone else from fixing urgent debt quickly. A README with exact commands and a seed script is often a one-day fix.
  • Slow or flaky pipelines push engineers to batch changes into large pull requests, which are harder to review and riskier to release. Count how often a rerun turns a red build green, since each one points to a flaky test or step to fix or delete.
  • When releases feel risky, teams ship less often and bundle more changes together, so each failure is bigger and harder to trace. Our guide to safe releases and rollbacks sets out the minimum setup for a small team.
  • Pricing logic copied into four screens means every change takes four edits, and one usually gets missed. Duplicated rules are typical schedule items, best fixed the next time the team works in that area.
  • This is the interest payment on speed debt, and engineers usually know where it sits. Two or three examples per module, with the real time taken, make the cost of delay evidence rather than a feeling.
  • Upgrading one major version at a time is routine, while jumping three at once can take weeks. Security fixes often ship only on newer versions, so a large upgrade gap turns speed debt into security debt.

Section 060 of 6 checked

How do you prioritize technical debt by cost of delay?

  • Outside the fix-now list, cost of delay is the deciding number. Count the steady cost, such as 20 engineering hours a month lost in a slow module, and the risk cost, such as an outage that grows more likely every quarter. Rough written estimates are enough to compare items.
  • Dividing cost of delay by fix size ranks items fairly, a rule product teams call weighted shortest job first: a two-day fix that saves a day a week beats a six-week refactor with the same saving. Sizes guessed from outside the code miss the hidden work, such as data migrations and the tests that must come first.
  • Some debt compounds. A missing tenant ID costs one migration today, and later a migration plus a backfill for every table added since, so compounding items move up the list even when their cost today is small.
  • Undecided items get reread at every planning meeting and decided never. Three explicit outcomes force a choice and keep the register short enough to use.
  • Debt paid down inside feature work in the same area costs less, because the code is already open and being tested. A scheduled item with no date is an accepted item nobody admitted to.
  • Accepting debt is a valid decision when the code is stable, rarely changed, or due to be retired. The GDS Way guidance on technical debt for UK government teams notes that risk does not map directly to priority, for example when a risky component will go away anyway, and asks teams to review every rating periodically.

Section 070 of 6 checked

How do you keep technical debt from growing back?

  • Deliberate debt is a sensible trade before a launch or a demo, as long as it is recorded when it is taken. A “debt introduced” field in the pull request template costs nothing and keeps the register current.
  • Rules that only run on laptops stop being followed in the first busy week. A required check holds every change to the same bar, whoever or whatever wrote it.
  • AI coding tools make large changes cheap to produce, and review is where new debt is either caught or merged. Our AI code review workflow shows how to split the work between automated review and the engineer who approves.
  • Without the reasoning, engineers either avoid code they do not understand or undo a choice that had a good reason. Our guide to architecture decision records includes a short template.
  • Without reserved time, scheduled items slip behind every feature request until they become incidents. A monthly look also catches items whose cost of delay has changed, such as a module that now changes every week.
  • Priorities shift as the product does, and a module nobody touched last quarter may sit on this quarter's roadmap. Once the register exists, each pass mostly updates scores rather than starting from scratch.

0 of 42 checked

Which tech debt should you fix first?

#

Fix technical debt first when it can expose data, lose data, or stop customers from paying, whatever the fix costs. Rank everything else by cost of delay divided by fix size.

Which failures are urgent?

#
  • A production dependency with a vulnerability exploited in the wild, or a runtime past end of life.
  • A known gap in authorization or tenant separation.
  • A secret in git history that has not been rotated.
  • Backups never restored, or a schema that exists only in production.
  • A money path with no alert, so a failure reaches you through a customer.

These go to fix now, ahead of any refactor. Most take days, though closing a tenant separation gap can take longer because it touches most queries.

What can you schedule or accept?

#

Schedule revenue and speed items whose cost grows each month, with an owner and a date, and pay them down alongside feature work in the same area. Accept items in stable or soon-retired code, in writing, with a review date.

When does an outside review make sense?

#

Get an outside review when the fix-now list is longer than your team can clear in two weeks, when nobody can answer a whole section, when the team is split on a rebuild, or when a fundraise depends on the answers. A Pixelact software audit is a fixed package from $2,500: about 3 to 5 days of review, a written report that ranks risks and fixes, a build path with rough costs, and a walkthrough call. If releases already break every week, software rescue starts with a rescue audit at the same price, which ends in a fix-or-rebuild call.

To see the format first, request an audit and ask for the sample report we made from one of our own products.

Checklist updates

Get an email when this checklist changes

We revise checklists when tools or advice change. Leave your email and we'll tell you when this one is updated. You'll also get the monthly newsletter, and every email has an unsubscribe link.

By subscribing, you agree to get the Pixelact newsletter by email. Every email has an unsubscribe link. Read the privacy notice.

FAQ

Questions about this checklist

Straight answers on what it covers, who should run it, and what to do with the results.

There is no correct percentage. A fixed share of each cycle, such as one day in ten, suits scheduled debt, but fix-now items jump the queue whatever the budget says, and accepted items get no time at all. Size the share so each scheduled item can meet its date. If the team has no room, an engineering retainer adds fixed monthly capacity, offered once Pixelact has worked in the code through a build or a stabilization sprint.

A bug is behavior that is wrong today, such as an invoice that adds tax twice. Technical debt is a shortcut in how the code is built that makes future changes slower or riskier, such as tax logic copied into four places. Debt often causes bugs, so a bug that keeps returning in the same module is a strong sign the debt behind it belongs on the fix-now or scheduled list.

Rarely. A feature freeze stalls the roadmap and often ends before the debt does. Clear the fix-now items, which usually take days, then pay scheduled debt down when the team next changes that area, and plan larger items as named tasks with an owner and a date. Pausing features in one area makes sense only when every change there breaks something else.

Show the register, not the code. List each fix-now item with its risk in plain words and the date it will close, then give the number of scheduled items with their plan and the accepted items with their reasons. “Backups have never been restored” is easier to weigh than a code quality score. Our guide to what a software audit covers shows a report format a non-engineer can read.

Usually not. Missing tests, slow queries, outdated dependencies, and duplicated logic can all be paid down in place. Replacing one part is worth weighing when its data model or security model blocks what the product must do next, and fixing it in place would touch most of its files anyway. Our guide to deciding whether to rebuild or refactor explains how to judge it part by part.

Next step

Need help closing the gaps?

Tell us what you're building and what the checklist turned up, or book a call if you're not sure where to start.

On the discovery call

  1. 01What prompted this now, and where things stand
  2. 02What a good outcome looks like
  3. 03Whether we're a fit, and what a next step could be

45 minutes. No slides, and no long questionnaire.