The Technical Debt Quadrant, Explained for Founders
Deliberate or inadvertent, prudent or reckless: the two questions that tell you how your codebase got into debt, and whether the way you build will keep putting it there.
The technical debt quadrant is a two-by-two grid for classifying technical debt by how it was taken on. One axis asks whether the debt was deliberate or inadvertent: did someone knowingly choose the shortcut? The other asks whether it was prudent or reckless: was the choice a sensible trade-off, or one made without regard for the cost? Martin Fowler described it in a 2009 post on his bliki, and it remains the most widely used way to talk about where debt comes from.
For a founder, the quadrant is useful for one reason: it separates debt you can schedule from debt that tells you something is wrong with how the product is being built. The first is a line item. The second keeps growing until the process behind it changes.
The four quadrants at a glance
| Reckless | Prudent | |
|---|---|---|
| Deliberate | "We don't have time for design." | "We must ship now and deal with consequences." |
| Inadvertent | "What's layering?" | "Now we know how we should have done it." |
The quotes are Fowler's own shorthand for each quadrant. Read across the rows and you get who knew; read down the columns and you get whether it was a reasonable call.
The quadrant builds on the metaphor Ward Cunningham introduced in 1992: shipping code you know is not quite right is like borrowing money. You move faster now, and you pay interest, in slower and riskier changes, until you pay the principal back by fixing it. Fowler's point was that not all borrowing is alike, and that a mess made through carelessness is still debt, just a much worse kind of loan.
Prudent and deliberate: the loan with a repayment date
What it sounds like: "We're launching without an admin dashboard and will run refunds by hand in the database for the first month. We'll build the dashboard once refunds pass a weekly number we've agreed on."
This is the only quadrant that is a strategy rather than an accident. The team knew what it was skipping, knew roughly what it would cost later, and decided the speed was worth it, usually to hit a launch, a demo or a funding conversation.
In an early-stage product it looks like: a single database with no read replicas, manual onboarding steps, a hard-coded pricing table, no automated tests on a feature you expect to throw away, a payment flow that supports one currency.
What to do: write it down. Prudent deliberate debt only stays prudent while the plan to repay it exists. Record each item with the trigger that should make you pay it back (a customer count, a contract, a date) and an owner. The failure mode here is not taking the loan; it is forgetting it. A shortcut with no ticket, no trigger and no owner drifts into the reckless column the day everyone who remembered it leaves.
Reckless and deliberate: the shortcut with no plan
What it sounds like: "We don't have time for design." Or, in founder terms: "Just get it working, we'll clean it up later," said every sprint, with no later ever scheduled.
The team knows it is cutting corners and has no intention or capacity to come back. This is the quadrant that does the most damage in young companies, because it compounds: each shortcut makes the next change harder, which creates more pressure, which produces more shortcuts. It is also the quadrant most likely to erode trust between whoever sets the deadlines and whoever writes the code.
In an early-stage product it looks like: copy-pasted business logic across several screens, secrets committed to the repository, features shipped straight to production with no staging environment, error handling that swallows failures silently, every new feature bolted onto the same file.
What to do: treat it as a process problem first and a code problem second. Fixing the worst items without changing the deadline pressure that produced them just resets the clock. Agree on a small non-negotiable floor (code review on every change, a staging environment, no secrets in the repo) before funding a cleanup. See how stage-appropriate reliability standards change once real customers depend on the product.
Reckless and inadvertent: debt nobody knew they were taking on
What it sounds like: "What's layering?" The people who built it did not know the practices they were skipping existed.
Nobody chose this debt, and nobody is tracking it. It surfaces later, usually all at once, when a new engineer opens the codebase or the product meets real load. It is common in products built by a single freelancer working without review, by a team stretched beyond its experience, or with AI coding tools accepted without anyone able to judge the output.
In an early-stage product it looks like: database queries built by string concatenation, no separation between the user interface and the business rules, authentication written from scratch, no migrations (the schema lives only in production), dependencies pinned to whatever version was current on day one.
What to do: you cannot classify what you cannot see, so the first step is an outside read of the code by someone who can recognise these patterns. A pre-engagement technical debt assessment is designed for exactly this. Then fix the skills gap that produced it: more of the same builders will produce more of the same debt. For codebases built with AI tools, see who should own the refactor-versus-rebuild decision.
Prudent and inadvertent: what you only learn by building
What it sounds like: "Now we know how we should have done it."
A capable team made reasonable decisions with what it knew, and the product taught them something new. Customers used a feature differently than expected, the data model fit the first market but not the second, or a better approach only became obvious after living with the design. Fowler's observation is that this kind of debt is unavoidable even for excellent teams: good design is partly learned by shipping.
In an early-stage product it looks like: a data model built around one customer type when you now serve three, a monolith whose module boundaries no longer match how the team is organised, an integration designed for one partner that now has to support many.
What to do: this is healthy debt to have. Pay it down where the code is changing anyway, and fold the lesson into the next design rather than launching a rewrite. Whether to repair or replace is a separate decision; see when to rewrite versus refactor a production codebase.
The quadrant tells you where debt came from, not what to fix first
People searching for "the technical debt quadrant" often mean one of two different grids, and mixing them up leads to bad decisions.
- Fowler's quadrant (deliberate/inadvertent × prudent/reckless) is about origin. It tells you whether the way the product is being built will keep producing debt.
- A prioritization matrix (cost to fix × ongoing drag, or impact × effort) is about order. It tells you which items repay the work soonest. This site walks through one in ranking and prioritizing technical debt findings and refactoring as a revenue decision.
Use them together. Tag every finding with its Fowler quadrant, then place it on the prioritization matrix. A cheap, high-drag item gets fixed first whichever quadrant it sits in. But if most of your findings sit in the reckless column, prioritizing alone will not help: the backlog will refill as fast as you clear it.
Security and dependency issues sit outside both grids. A known vulnerability or an end-of-life library gets fixed on its own track, whatever quadrant it came from and however little drag it causes day to day.
How to run a quadrant review on your own codebase
You do not need to read code to run this, but you need someone in the room who can.
- List the debt. Ask your engineers (or an outside reviewer) for the ten to twenty things that slow them down most or worry them most. Keep each to one line.
- Ask the two questions for each item. Did we know we were doing this at the time? Was it a reasonable trade-off given what we knew? Place it in a quadrant. Disagreement here is useful information: if the engineer says "deliberate" and the founder never heard about it, the trade-off was never agreed.
- Look at the pattern, not the items. Mostly prudent: you are managing debt, keep going. Heavy in reckless-deliberate: the deadlines are writing the code. Heavy in reckless-inadvertent: you are missing experience, not time.
- Score each item for cost and drag. How much effort to fix, and how much it slows every change or risks an incident until it is fixed.
- Pick a response per item: repay now, repay when that code is next changed, schedule against a trigger, or accept it and leave it. Code nobody touches and nothing depends on can often be left alone.
- Give the list an owner and a review date. Revisit it on a fixed rhythm (monthly or quarterly suits most early-stage teams) and whenever you plan a large feature.
A worksheet you can copy
| Finding | How it got there (quadrant) | What it costs us now | Effort to fix | Response | Owner | Revisit |
|---|---|---|---|---|---|---|
| Refunds run by hand in the database | Prudent, deliberate | A few hours of support time a week | Small | Build admin tool at agreed trigger | Name | Date |
| No staging environment | Reckless, deliberate | Every release is tested in production | Medium | Fix now | Name | Date |
| Business rules mixed into UI code | Reckless, inadvertent | Slows every feature in checkout | Large | Refactor when checkout is next changed | Name | Date |
| Data model assumes one customer type | Prudent, inadvertent | Workarounds for the second segment | Large | Redesign in next quarter's plan | Name | Date |
The rows are examples of the kind of entry that goes in each column, not a diagnosis of your product. Fill in your own.
Common mistakes with the quadrant
- Using it to assign blame. "Reckless" describes a decision, not a person. Most reckless debt in startups comes from deadlines and missing experience, not carelessness. A review that turns into blame stops getting honest answers.
- Treating "deliberate" as automatically safe. Deliberate debt is only prudent while someone is tracking it. The quadrant classifies how debt started, not how it is being managed now.
- Using it as a priority list. A prudent item can be the most urgent thing on your list; a reckless one in dormant code may never be worth fixing.
- Classifying without reading the code. A founder's memory of what was decided is half the picture. The other half is what the code actually does, which takes an engineer, ideally one who did not write it.
- Doing it once. Debt moves between quadrants. The prudent shortcut you never repaid is, a year later, reckless debt that someone new has to discover.
For explaining the results to a board or a non-technical co-founder, see communicating technical debt to non-technical founders.
Frequently asked questions
Who created the technical debt quadrant?
Martin Fowler, in a 2009 post on his website (martinfowler.com/bliki/TechnicalDebtQuadrant.html). It builds on the technical debt metaphor Ward Cunningham introduced in 1992.
What are the four types of technical debt in the quadrant?
Prudent and deliberate (a conscious trade-off with a plan to repay it), reckless and deliberate (a known shortcut with no plan), reckless and inadvertent (debt taken on without knowing better practices existed), and prudent and inadvertent (debt a good team only recognises after learning from the product).
Is all technical debt bad?
No. Prudent, deliberate debt is a legitimate way to ship sooner, as long as it is recorded with a trigger for repaying it and an owner. Prudent, inadvertent debt is a normal result of learning. The reckless quadrants are the ones that signal a problem with how the product is being built.
Is the technical debt quadrant the same as a prioritization matrix?
No. Fowler's quadrant classifies how debt was taken on. A prioritization matrix (such as cost to fix against ongoing drag, or impact against effort) decides what to fix first. Most teams need both.
Which quadrant does AI-generated code fall into?
It depends on who accepted it and what they knew. Code accepted from an AI tool by someone who could not judge it usually lands in reckless and inadvertent. The same code reviewed by an experienced engineer who knowingly accepted a shortcut to meet a deadline, and recorded it, is prudent and deliberate.
How often should a team review its technical debt?
On a fixed rhythm, often monthly or quarterly for an early-stage team, and before any large feature or engineering engagement that will touch the affected code.


