Technical debt should be prioritised like any other product investment: by the harm it creates, the change it blocks, the risk it carries and the evidence that paying it down will improve future delivery.
Many teams still manage debt through two weak signals: developer frustration and the age of the code. Neither is enough. An awkward module can sit untouched for years without affecting the business, while a smaller problem in authentication, payments or a frequently changed workflow can add risk and delay every month.
The useful question is not, “How much technical debt do we have?” It is, “Which debt is charging us the most interest now, and which debt is about to become expensive because of what the product needs next?”
This guide is for UK product leaders, founders and engineering managers who need a transparent way to answer that question. It is management guidance rather than a security audit or professional risk assessment.
Technical debt is not simply bad code
The technical-debt metaphor describes a trade-off. In his explanation of technical debt, Martin Fowler describes internal quality deficiencies that make future changes harder, with the extra effort of changing the system acting like interest. In the technical-debt quadrant, he distinguishes deliberate from inadvertent debt, and prudent from reckless debt.
A team may deliberately simplify an architecture to validate an MVP quickly. That can be sensible if the shortcut is visible, bounded and cheap to reverse. Another team may inherit undocumented dependencies, obsolete libraries or a fragile deployment process without realising the cost until the product grows.
The label “technical debt” should therefore cover more than untidy code. A practical register usually includes four types.
Intentional debt
A conscious trade-off taken for a short-term business reason. Examples include temporarily duplicating logic to meet a launch date or accepting a manual operational step while demand is uncertain.
Intentional debt is not automatically bad. It becomes dangerous when the decision, repayment trigger or owner disappears.
Accidental debt
Debt created without a deliberate decision: inconsistent architecture, missing tests, uncontrolled coupling, duplicated data rules or fragile integrations.
This often appears gradually as teams change, deadlines compress and product assumptions evolve.
Environmental debt
The product may be internally well structured but depend on ageing runtimes, unsupported packages, old SDKs, weak CI/CD, obsolete operating-system assumptions or infrastructure that no longer matches usage.
The UK National Cyber Security Centre's secure-development principles include maintainable code, protected repositories, secure build and deployment pipelines, continuous security testing and planning for flaws. Those are not merely cosmetic concerns once a system is operating in production.
Knowledge debt
Sometimes the problem is not in the code. Critical behaviour may exist only in one person's memory. Runbooks may be missing. Ownership may be unclear. A system can be technically sound and still expensive to change because nobody can confidently explain its boundaries.
These categories prevent the conversation becoming a generic complaint about code quality.
Look for the interest, not just the principal
Technical debt becomes commercially relevant when it changes how the business can operate.
A useful register connects each item to observable effects.
Delivery friction
Does a change take longer than it should because engineers must work around a brittle area, repeat manual verification or coordinate across unnecessary dependencies?
One slow task proves little. A recurring pattern across several changes is more useful evidence.
Reliability and incident exposure
Does the debt contribute to failed releases, service interruptions, rollback difficulty, inconsistent data or support tickets?
If the same component appears repeatedly in incident reviews, the debt may already be charging visible interest.
Security and compliance exposure
Does the item affect authentication, secrets, access controls, unsupported dependencies, auditability or the integrity of the build/deployment path?
Security-sensitive debt should not be reduced to a normal feature-priority score. Some issues warrant immediate treatment because the downside is asymmetric. The NCSC's build-and-deployment guidance discusses controlled deployment, appropriate automation, review, secrets and third-party libraries.
Product-option cost
Does the debt make an upcoming capability unusually expensive?
A fragile billing model may be tolerable until the business wants multiple plans. A tightly coupled mobile client may be tolerable until several markets need different rules. A manual data migration may be tolerable until customer volume grows.
This is strategic leverage: an item can be worth addressing not because it is painful today, but because it unlocks an important next move.
Team and ownership cost
Does only one person understand the area? Is review slow because the logic is difficult to reason about? Are new engineers reluctant to change it?
Knowledge concentration can be an early warning of future delay.
Build one shared technical-debt register
Debt should be visible in the same planning conversation as features, incidents and commercial commitments.
| Field | Question |
|---|
| Debt item | What is the specific constraint or weakness? |
| Product impact | Which user, workflow or business capability is affected? |
| Evidence | What shows the problem is real? |
| Likelihood | How likely is cost or failure in the planning horizon? |
| Urgency | Why now rather than later? |
| Effort | What is the approximate remediation size and uncertainty? |
| Strategic leverage | What future work becomes easier or possible? |
| Owner | Who will keep the evidence current? |
| Completion evidence | How will we know the debt is reduced? |
Avoid entries such as “clean architecture”, “fix backend” or “refactor app”. They are too broad to compete fairly with product work.
Consider this hypothetical example:
Checkout pricing rules exist in three services. Recent pricing changes required coordinated edits and regression fixes. Consolidating those rules would reduce the change surface before planned subscription work.
That statement identifies location, evidence to collect, consequence and strategic reason. It does not imply a real FlutterCraft client experience.
Score debt without pretending the numbers are precise
A score is useful for comparison, not for manufacturing certainty.
A simple editorial model is:
Priority = (impact × likelihood × urgency × strategic leverage) ÷ effort
Use a scale from 1 to 5 for each input, then discuss the assumptions.
| Illustrative item | Impact | Likelihood | Urgency | Leverage | Effort | Score |
|---|
| Unsupported authentication dependency | 5 | 4 | 5 | 3 | 2 | 150 |
| Duplicate reporting logic | 3 | 4 | 2 | 3 | 3 | 24 |
| Old admin styling layer | 1 | 2 | 1 | 1 | 4 | 0.5 |
These numbers are entirely illustrative, not probabilities or cost estimates. Their purpose is to expose why the team believes one item deserves attention before another.
Add override rules
Do not let a formula overrule judgement.
Create explicit overrides for:
- confirmed security vulnerabilities;
- data-integrity risk;
- legal or contractual obligations;
- unsupported production dependencies;
- a known blocker for a committed capability;
- repeated incidents with meaningful customer impact.
An override does not mean everything is urgent. It means the team has agreed which classes of evidence bypass the normal queue.
Prioritise debt beside features
If technical debt lives in a separate list that product leaders never see, it will usually lose.
Bring high-value debt into the same prioritisation discussion as product work. Compare both in terms of outcomes.
A feature might say:
Enable self-service account upgrades to reduce support dependency.
A debt item might say:
Consolidate plan-entitlement logic so self-service upgrades can be introduced without inconsistent permissions.
Now the relationship is visible. The debt is not just engineering maintenance; it is part of the path to a product outcome.
FlutterCraft's guide to prioritising features when stakeholders disagree applies the same discipline: make decision criteria explicit instead of letting the loudest request win.
Use capacity rules carefully
Teams often ask whether to reserve 10%, 20% or another share of capacity for debt. There is no universal percentage that is right for every organisation.
A capacity rule can still keep maintenance from disappearing.
Baseline capacity
Reserve a recurring allowance for small maintenance, dependency updates, test improvements and documentation.
Triggered capacity
Increase debt work when agreed signals are crossed: incident frequency, failed deployment rate, support burden, dependency risk or change lead time.
Initiative-linked capacity
When a roadmap initiative touches a debt-heavy area, include necessary remediation in that initiative rather than pretending the feature can be delivered independently.
This aligns with FlutterCraft's app maintenance budgeting guide: production software needs continuing attention beyond visible feature delivery.
Define completion evidence before starting
“Refactored” is not an outcome.
An item should have evidence that the burden has reduced, such as:
- one source of truth replacing duplicated business rules;
- an unsupported dependency upgraded and compatibility tests passing;
- automated checks added to a deployment path;
- a repeatable build documented and verified;
- a manual recovery step exercised successfully;
- documentation sufficient for another engineer to make a safe change;
- reduced errors or support work over an agreed observation period.
The evidence must match the reason for prioritising the debt.
If the problem was repeated pricing defects, code coverage alone is not sufficient proof. If the problem was deployment risk, a tidier module structure is not sufficient proof.
Avoid the rewrite trap
A large rewrite can feel satisfying because it promises a clean start. It can also create a long period in which the old system still needs support while the new one recreates existing behaviour.
Fowler's technical-debt analysis highlights why an ugly but stable area may deserve less attention than a frequently changed area where the interest is paid repeatedly.
Ask:
- How often do we change this area?
- What does the debt cost when we change it?
- Will the planned product direction increase that cost?
- Can we reduce the debt incrementally?
- Would replacement remove a real constraint or mainly reset the style?
For products moving from prototype to dependable production, FlutterCraft's prototype-to-production readiness guide helps distinguish debt from fundamental ownership, security and operational gaps.
Run a monthly technical-debt review
A short recurring review works best if the register is maintained continuously.
Use these questions:
- Which new debt items have evidence?
- Which existing items changed in impact, likelihood or urgency?
- Which roadmap items will touch debt-heavy areas?
- Which security, dependency or operational items need an override?
- Which debt item should move into the next delivery window?
- Which items should be deliberately deferred, with a review trigger?
- Did completed debt work produce the expected evidence?
The last question matters. A team that never checks outcomes can spend months improving architecture without knowing whether reliability or delivery improved.
The decision rule
Prioritise technical debt when the expected cost of leaving it in place becomes more important than the opportunity cost of fixing it.
That cost can appear as recurring delivery friction, incident risk, security exposure, operational burden or a blocked product option.
The practical discipline is to make debt specific, connect it to user or business effects, record evidence, score transparently, apply overrides, plan it beside feature work and define completion evidence. Deliberately defer low-interest debt rather than pretending everything must be fixed.
That turns technical debt from an argument between engineering and product into a shared investment decision.
For more practical product and engineering frameworks, join the FlutterCraft newsletter.