Book A Call
  1. Home
  2. Insights
  3. What is technical debt?

Technology

What is technical debt?

Zahid Younis
Co-founder and CTO · · 24 min read
What is technical debt?

Technical debt is the extra future work created when a software team takes a shortcut today, such as skipping tests, copying code or using an outdated design, instead of the cleaner approach that would take longer. Like financial debt, some is sensible and helps you move fast; too much makes every new feature slower, riskier and more expensive, until the team spends more time fighting the code than improving the product.

We have taken over and modernised many apps, including helping Cubeware move a long-lived analytics product to SaaS, and Rounded Labs has been building software since 2007, so we have seen debt at every stage, from a one-month-old prototype to a system older than some of the developers who maintain it. This guide explains technical debt in plain terms for founders, product owners and managers: what causes it, how it shows up in cost and risk, how to measure it without being technical, and how to pay it down without stopping the roadmap.

Key facts

  • All software has some technical debt; the goal is to manage it, not eliminate it.
  • Common causes: deadlines, changing requirements, missing tests, outdated libraries, team turnover.
  • Symptoms: slow delivery, frequent bugs, fear of changing code, long onboarding for new developers.
  • A common practice is to reserve 10 to 20% of each sprint for paying debt down.
  • Severe debt can justify a rebuild, but incremental refactoring is usually cheaper and safer.
  • You can explain debt to a board in business terms: principal, interest, risk and plan.
  • An independent code audit is the fastest way to turn a vague worry into a costed list.

Where does the term come from?

Ward Cunningham, one of the authors of the Agile Manifesto, coined the metaphor in 1992: shipping imperfect code is like going into debt, and the “interest” is the extra effort every later change costs until the code is improved. The metaphor stuck because it lets engineers explain a technical problem in business terms. A manager may not understand “tight coupling between modules”, but anyone who has paid interest understands why a small loan left alone becomes a large one.

The idea has been extended since. Martin Fowler‘s well known writing on the subject separates debt taken on deliberately from debt that arrives by accident, and debt incurred prudently from debt incurred recklessly. That split is the most useful one for managers, and we use it below.

What is the difference between technical debt, bugs and bad code?

These terms get mixed up, and mixing them makes conversations confusing.

Term What it is Example
Bug The software does not do what it should The basket total is wrong when a voucher is applied
Technical debt The software works, but is harder than it should be to change Voucher logic is copied into four places
Missing feature The software does not do something yet No gift cards
Bad code Code that is unclear or fragile; often a source of debt A 3,000 line file that nobody wants to touch
Legacy system Older software that is still in use and hard to replace A ten year old back office tool

A bug has to be fixed because users notice it. Debt can sit silently for months and only reveals itself when you try to change something. That is why it is easy to postpone and expensive to ignore.

What causes technical debt?

Cause Example
Deliberate shortcuts Hard-coding values to hit a launch date
Changing requirements A design built for one market stretched to five
Missing tests Changes that need slow manual checking every time
Outdated dependencies Old libraries that block platform updates
Inconsistent structure Several developers solving the same problem in different ways
Knowledge loss The original developers leave and nobody understands key parts
Missing documentation Decisions that live only in someone’s head
Rushed handovers A new agency inherits code with no explanation
Growth beyond the design A system built for 500 users now serves 50,000

What are the four types of debt?

Using the idea of deliberate and accidental, prudent and reckless, you get four kinds.

Type What it sounds like Is it acceptable?
Deliberate and prudent “We will ship now and fix the structure after launch” Yes, if you write it down and plan to repay it
Deliberate and reckless “We do not have time for design” Rarely, and it grows quickly
Accidental and prudent “Now that we have built it, we see a better way” Normal, a natural result of learning
Accidental and reckless “What is a layered architecture?” A skills and oversight problem to fix

Most healthy products carry the first and third kinds. Trouble starts when the second and fourth dominate, or when any kind is left unrecorded.

Bar chart of suggested share of team capacity spent on technical debt by product state

How does technical debt affect a business?

  • Slower features. Simple changes take days instead of hours, and estimates become unreliable. Roadmap dates slip, and sales and marketing lose confidence in engineering promises.
  • More bugs. Fragile code breaks in unexpected places. Fixing one issue creates another, and the same defects return.
  • Higher maintenance costs. Annual updates for new iOS and Android versions, announced on Apple Developer and Android Developers, take longer, as we explain in App maintenance costs in the UK and How to prepare your business app for each new iOS release.
  • Security risk. Outdated libraries carry known vulnerabilities, a theme covered in our mobile app security checklist. The OWASP Foundation and the UK National Cyber Security Centre both publish current guidance on keeping software patched.
  • Hiring and handover problems. New developers take longer to become productive, and changing supplier becomes risky. See How to switch app agencies without losing your app.
  • Poor performance. Inefficient design shows up as slow screens and battery drain; see Why apps feel slow.
  • Lower morale. Good engineers dislike working in code they cannot trust, and they leave. Replacing them adds further cost.
  • Reduced options. Debt narrows what you can do next. Adding AI features, a new payment method or a new market becomes a larger project than it should be.

What does the interest look like in money?

The real cost is rarely a single invoice. It is spread across many small slowdowns. Here is an illustrative example, using made up figures to show the mechanism. These are not benchmarks.

Item Healthy codebase Heavily indebted codebase
Time to add a simple payment option 3 days 10 days
Testing effort per release 1 day, mostly automated 4 days, mostly manual
Releases per month 4 1
Share of team time spent on bug fixes 15% 45%
Time for a new developer to make a first safe change 1 week 6 weeks

If a team costs £40,000 a month and 45% of it goes on fixing avoidable problems, then about £18,000 a month is interest. Even if the true figures differ, the exercise gives you a way to compare the cost of repayment with the cost of carrying the debt.

What are the warning signs that debt is getting out of hand?

You do not have to read code to spot trouble. Listen for these phrases from your team or supplier, and watch for the patterns behind them.

  1. “We cannot touch that part.” Areas of the product that nobody wants to change are usually where debt is deepest.
  2. “It should only take a day, but…” Repeated underestimates mean the team no longer understands the system.
  3. “It works on my machine.” Inconsistent environments and unreliable builds slow every release.
  4. “We need to test everything by hand.” Missing automated tests raise cost and risk with each change.
  5. “Only one person knows how that works.” This is a knowledge risk as well as a technical one.
  6. “We cannot upgrade because it will break.” Frozen dependencies are a growing security and compatibility problem.
  7. “The same bug keeps coming back.” The root cause has not been addressed.
  8. “Each release gets bigger and scarier.” Releases should get smaller and calmer over time.

If three or more of these sound familiar, an audit is worth the cost.

How do you measure technical debt?

There is no single number, but useful signals include:

  • Lead time from idea to release, and whether it is growing.
  • Change failure rate: how often releases cause problems.
  • Test coverage of critical paths.
  • Dependency age: how far behind current versions your libraries are.
  • Static analysis findings for complexity and duplication.
  • Developer estimates: how often “small” changes turn out large.

The research programme run by DORA (DevOps Research and Assessment) popularised four delivery measures that map well to this: how often you deploy, how long a change takes to reach users, how often changes cause failures and how quickly you recover. You can track these without reading a line of code, and a worsening trend is a strong hint that debt is accumulating.

How do you run a simple debt review yourself?

Before commissioning anything formal, do this in an hour with your technical lead.

  1. List the five areas of the product that change most often.
  2. For each one, ask: how long does a typical change take today, and how long should it take?
  3. Ask which of them has automated tests and how long the tests take to run.
  4. Ask which libraries or frameworks are more than two major versions behind.
  5. Ask what would happen if the person who knows each area left tomorrow.
  6. Score each area from 1 (healthy) to 5 (risky) and write one sentence of reason.

The result is not a scientific measure, but it gives you a ranked list to work from and it forces useful conversations.

What does an independent code audit cover?

A short code audit by an independent team can turn these signals into a prioritised list. A good audit usually reviews architecture, code quality, test coverage, dependency health, security basics, build and release process, documentation and operational risks. It should end with a ranked list of findings, each with an impact, a rough cost to fix and a recommended order, plus a clear view of whether to refactor, replace in stages or rebuild.

At Rounded Labs, our Tech Architecture Audit is £7,500 fixed, and our Legacy App Rescue Assessment, designed for older apps that are struggling, is £6,500 fixed. Both are priced before work starts, and you own the report whether or not you work with us afterwards. For a do it yourself view, see How to audit an existing app’s code. If you are inheriting code from another team, How to take over an app built by someone else and How to switch app agencies without losing your app cover the handover.

Worried about the state of your app’s code? We audit codebases and give you a costed plan: what to fix, what to leave, and whether a rebuild is worth it. Book a 30-minute call with a co-founder.

How do you pay technical debt down?

  1. Make it visible. Keep a list of known debt with its impact and rough cost.
  2. Budget for it. Reserve 10 to 20% of each sprint, or schedule a dedicated “health” sprint each quarter.
  3. Fix as you go. Improve code you are already changing for a feature (the “boy scout rule”: leave it cleaner than you found it).
  4. Add tests first around fragile areas, so changes are safe.
  5. Update dependencies regularly rather than in painful jumps.
  6. Replace in stages. For large legacy systems, replace parts one at a time (the “strangler fig” approach) instead of a big-bang rewrite.

How should you decide what to fix first?

Not all debt deserves repayment. Rank each item on two scales: how much it costs you today, and how much work it takes to fix.

Low effort to fix High effort to fix
High cost today Fix now Plan and schedule it
Low cost today Fix when nearby Leave it and record it

Take, for example, three items on a debt list.

  • A duplicated payment function costs two extra days every time the payment provider changes, and takes three days to merge. High cost, low effort: fix now.
  • A library two versions behind blocks a platform update due in four months and needs two weeks of testing. High cost, high effort: schedule it before the deadline.
  • An old screen with messy styling that nobody changes. Low cost, low effort: fix if you happen to touch it. Low cost, high effort items are simply recorded and left.

What are the main repayment techniques?

Technique What it means Best for
Refactoring Restructuring code without changing behaviour Messy but working areas
Adding tests Writing automated checks around existing behaviour Fragile or critical areas
Dependency upgrades Moving libraries and frameworks to current versions Security and platform compatibility
Modularisation Splitting a large tangle into separate parts Slow, risky releases
Documentation Writing down how and why things work Knowledge held by one person
Automation Build, test and release pipelines Slow or error prone releases; see What is CI/CD for apps?
Replacement in stages New components built beside the old, then switched over Large legacy systems
Rebuild Starting again with a new design Obsolete technology or architecture

How do you protect the roadmap while paying debt down?

Product owners worry, rightly, that debt work steals time from features. Three habits keep the balance.

  1. Tie debt work to features. “To add Apple Pay safely, we first need to consolidate the payment code” is an easier conversation than “we need to refactor”.
  2. Use a fixed share. A standing 10 to 20% allocation is easier to defend than arguing about it every sprint.
  3. Show the result. After each repayment, report what improved: a faster build, fewer incidents, shorter lead time. Visible wins keep support.

When is a rebuild better than refactoring?

A rebuild can make sense when the underlying technology is obsolete, the architecture cannot support the product’s direction, or the cost of each change has grown beyond the cost of starting again. Rebuilds carry their own risks: they take longer than expected and must replicate years of hidden behaviour. Rebuild or refactor: what it costs to fix an old app compares the costs of rebuilding and refactoring, and Turning legacy software into SaaS shows how we approached a legacy-to-SaaS move.

Question Points towards refactoring Points towards rebuilding
Is the core technology still supported? Yes No, or support is ending
Does the architecture fit where the product is going? Mostly No, it blocks the plan
Can you add tests around existing behaviour? Yes Almost impossible
Do you still understand what the system does? Yes No, and no one can explain it
Can the business live with change in stages? Yes It needs a clean break
Is the cost of each change rising steadily? Slowly Sharply

Why do rebuilds so often go wrong?

  • Hidden behaviour. Old systems contain years of quiet fixes for edge cases that nobody wrote down. A rebuild must rediscover them.
  • Moving target. The business keeps changing while the rebuild runs, so the new system is out of date on arrival.
  • Double running costs. You pay for the old and the new until the switch.
  • Big bang risk. Switching everything on one day concentrates the danger.

The staged alternative, often called the strangler fig approach, wraps the old system and replaces one capability at a time. It is slower to start and safer to finish. Our work with Cubeware on moving a mature analytics product to SaaS illustrates the case for planned, staged modernisation, and our guide to legacy software to SaaS for German Mittelstand companies covers a similar journey.

Replacing a legacy system one capability at a time.

Is all technical debt bad?

No. Taking on debt deliberately to test an idea quickly is often the right call, especially for an MVP. Our explanation of what an MVP is shows why early speed matters. The problem is unplanned debt that nobody tracks, and debt that is never repaid once the product proves itself.

A healthy pattern looks like this:

  1. Prototype fast. Accept shortcuts to learn quickly.
  2. Write the shortcuts down. Record them as debt items with an owner.
  3. Validate. Decide, with real users, whether the idea has legs.
  4. Repay before scaling. Before heavy marketing, spend a planned period making the foundations solid.

An unhealthy pattern skips steps 2 and 4: the prototype becomes the product, and nobody remembers why things were done the way they were.

How does technical debt show up in common app situations?

What does it look like in an early stage startup?

A small team ships a first version in a few months using whatever works. Debt is high, but so is learning. The danger point comes after the first successful funding round or growth push: the team now has to add features and people at the same time on a base that was never designed for either. Plan a repayment period right after validation, before you hire many developers.

What does it look like in a business with an older app?

An app built five or six years ago still earns money but is difficult to update. Operating system changes cause surprise breakages, and the original supplier may no longer exist. Here the first step is usually an assessment to see what is salvageable, as discussed in Rebuild or refactor. Our Legacy App Rescue Assessment at £6,500 is designed for exactly this situation.

What does it look like after a change of supplier?

New teams often judge the previous team’s code harshly. Some of that is fair, and some is simply unfamiliarity. Insist on a structured handover, an independent review and access to all accounts, source code and documentation. Who owns the code? IP, contracts and escrow for UK app projects explains the ownership points to check, and How to rescue a failing app project covers more serious cases.

What does it look like in a large organisation?

Several teams, several systems and years of integrations produce debt that sits between systems as much as inside them. Mapping dependencies and ownership matters more than polishing any single codebase.

What kinds of technical debt exist in a mobile app?

Debt is not only messy code. Naming the kinds helps you find them and pick the right fix.

Kind What it looks like Typical fix
Code debt Duplicated logic, giant files, unclear names Refactoring in small steps
Architecture debt Everything depends on everything; one change breaks several screens Introduce clear boundaries, then modularise
Test debt Few or no automated tests; heavy manual checking Add tests around critical paths first
Dependency debt Libraries, frameworks and SDKs far behind current versions Upgrade regularly in small jumps
Platform debt Use of deprecated iOS or Android features Plan migration before the old feature is removed
Infrastructure debt Manual deployments, fragile servers, no monitoring Automate builds and releases; add alerts
Data debt Inconsistent records, no clear schema, messy migrations Clean and document the data model
Design debt Inconsistent screens, patterns and components Build a shared design system; see What is a design system?
Documentation debt Knowledge held in people’s heads Short written guides and decision notes
Process debt No review, no definition of done, unclear ownership Agree and enforce lightweight team rules

Why does mobile add its own pressure?

Mobile apps depend on platforms that change on a fixed calendar. Apple and Google release new operating system versions every year, retire older interfaces and tighten store rules. A web page can sit untouched for years; an app that is not updated slowly stops working properly or gets flagged by the stores. That means mobile debt has deadlines attached. A library that blocks a required update turns from an annoyance into a dated business risk. It is one reason that App maintenance costs should be budgeted every year, not treated as a one off.

Other mobile specific sources of debt include supporting many old devices because nobody has checked usage data, leaving offline behaviour as an afterthought (see How to make your app work offline), and choosing a backend approach early that no longer fits as the product grows (see Firebase, Supabase or a custom backend?).

What does a debt register look like?

A register is a simple shared table. It turns vague complaints into decisions. Keep it short, keep it current and review it every month.

ID Item Area Impact today Risk Effort Owner Decision
D1 Payment code duplicated in three screens Checkout Extra 2 days per payment change Missed fix causes failed payments 3 days Lead developer Fix this sprint
D2 Analytics SDK two major versions behind Tracking Blocks OS update Possible store rejection 5 days Mobile developer Schedule before spring release
D3 No tests for login and basket Core flows Slow manual checks Revenue loss if broken 8 days QA lead Two sprints
D4 Old admin screen styling Back office None None 2 days Unassigned Leave, review in six months

Each row answers five questions: what is it, what does it cost today, what could go wrong, how long would it take and who decides. The figures are examples, not benchmarks.

Who should be in the review meeting?

A short monthly meeting works best with the lead developer, the product owner and someone from the business who can speak to risk and budget. Thirty minutes is enough. The agenda is simple: review new items, check the progress on those in flight, and agree what fits in the next month. If your supplier is an agency, ask them to bring the register to your regular catch ups. Our guide on How to read an agency’s weekly report shows what good reporting looks like.

What does a worked example look like?

A UK retailer has a loyalty app launched four years ago. It earns steady revenue, but each change seems to take longer than the last. The marketing team wants a new offers feature before the autumn campaign, and the supplier quotes eight weeks for something the team expected to take three.

An independent review finds the following:

  1. The offers logic is copied into the basket, the account page and the checkout, with small differences between each copy.
  2. The app has almost no automated tests, so every release needs three days of manual checking.
  3. Two key libraries are far behind, and one will block the next iOS update.
  4. The only developer who understands the loyalty points calculation left a year ago.

The team uses the quadrant approach.

Item Cost today Effort Action
Consolidate offers logic High, affects the new feature directly Medium Do first, as part of the offers work
Add tests around basket and checkout High, three days per release Medium Do alongside, starting with the most used flows
Upgrade the blocking library High, dated deadline Medium to high Schedule before the iOS update
Document the points calculation Medium, knowledge risk Low Do in the first two weeks
Restyle old screens Low High Leave and record

The result is a plan that delivers the offers feature, removes the main cause of the delay and meets the platform deadline, without a rewrite. Roughly a third of the first quarter’s capacity goes on debt work, falling to about 15% once the worst items are resolved. The figures are illustrative, but the pattern is typical: pay down the debt that sits in the path of the next feature, so the business sees both progress and results.

What questions should you ask your developers or agency?

You do not need to understand the answers in detail. You need to see whether the team has honest answers.

  1. What are the three parts of the app you are most worried about, and why?
  2. How long does it take to release a small fix, from decision to users?
  3. What share of the app is covered by automated tests, and which areas are not?
  4. Which libraries and tools are behind current versions, and what would an upgrade involve?
  5. If your lead developer was unavailable for a month, what would stop?
  6. What shortcuts did we take in the last release, and when will we fix them?
  7. What is the next platform deadline, such as a new iOS release, and are we ready?
  8. If we doubled the number of users, what would break first?

For more on questions to ask suppliers before you sign anything, see 20 questions to ask an app developer before you sign and App agency vs freelancer vs in-house team.

What common mistakes do teams make about technical debt?

  • Hiding it. Teams that conceal shortcuts to keep stakeholders happy create larger problems later.
  • Treating it as an engineering topic only. The cost shows up in the business, so decisions about it belong to the business.
  • Waiting for a perfect moment. There is never a quiet period. Build repayment into the normal rhythm.
  • Refactoring without tests. Changing structure with no safety net trades one problem for another.
  • Starting a rewrite out of frustration. Anger at the old code is not a business case.
  • Chasing a score. Tools that produce a debt number can help, but a clean score on an unimportant area wastes effort.
  • Gold plating. Not every rough edge needs fixing. Perfect code that no one changes has no return.
  • Ignoring the people. Debt grows fastest when teams are overworked, turn over often or lack time to learn.

When should you bring in outside help?

Consider an independent view in these cases.

Situation Why an outside view helps
You are about to raise money or sell the business Investors and buyers will check the code; surprises cost leverage
You are changing supplier You need to know what you are inheriting
Estimates keep growing A neutral review shows whether the problem is scope or code
A critical person is leaving Capture knowledge before it walks out
A platform deadline is close You need a realistic plan, not hope
You are choosing between refactor and rebuild The decision is expensive and hard to reverse

An outside review does not have to lead to a large project. Many of our audits end with a short list of fixes that the existing team can carry out. If you want us to look, our work on the Superdry app, for a brand with 768 locations in over 100 countries, taught us how much careful modernisation matters when the stakes are high, and our pricing page lists the fixed fees for audits and assessments.

How do you explain technical debt to a board or investors?

Use the business terms the metaphor was designed for:

  • Principal: the work needed to fix the shortcut, in days or money.
  • Interest: the extra time every related change costs while the debt remains, for example “each payments change takes three days instead of one”.
  • Risk: what could go wrong, such as a security issue or an app store deadline missed.
  • Plan: how much capacity you will spend on it, and what improves as a result, such as faster releases or fewer incidents.

Framed this way, a request for “refactoring time” becomes a normal investment decision. A one page summary works well:

Item Principal Interest Risk Proposed action
Duplicated payment code 5 days 2 days per payment change Missed fix causes failed payments Merge in next sprint
Old analytics library 10 days Blocks iOS update next spring Store rejection Schedule for Q1
No tests on checkout 8 days Slow manual testing each release Revenue loss if bug ships Add tests over two sprints

The figures above are examples to show the format, not benchmarks. For help with the wider case for investment, see How to build a business case for a mobile app and How to plan an app budget for the next financial year.

How do you stop debt building up again?

Repaying debt without changing habits just resets the clock. Put these practices in place.

  1. Agree a definition of done that includes tests, review and updated documentation.
  2. Review code before it merges. A second pair of eyes catches many problems early.
  3. Automate the boring checks. Linting, tests and builds should run on every change. What is CI/CD for apps? explains the basics.
  4. Track dependencies. Review libraries on a schedule, and update small and often.
  5. Hold short retrospectives that include a “what slowed us down?” question, and record the answers.
  6. Control scope changes. Late changes often force shortcuts; see How to manage scope changes without blowing the budget.
  7. Test properly before release. App testing explained shows how QA, UAT and beta testing fit together.
  8. Keep a decisions record. Short notes on why you chose an approach prevent repeated debate and lost knowledge.

How do you keep a supplier honest about debt?

If an agency or contractor builds your app, ask for these at every milestone: a list of known shortcuts, test results, a dependency list with versions and a note of anything that will need attention in the next six months. A good supplier will volunteer this. A supplier who dislikes the question may be hiding something. Our guides on red flags when hiring app developers and how to tell if an app project is off track list further warning signs. Our own projects are fixed price, agreed before development starts, which keeps the scope and the quality bar clear for both sides; see Fixed price vs time and materials for app projects and our pricing page.

What about AI generated code and debt?

AI coding assistants speed up writing, and they can also speed up the accumulation of debt. Generated code is often plausible but inconsistent with the rest of the system, repeats patterns and skips edge cases. Used well, tools help with tests, documentation and mechanical refactoring. Used carelessly, they let large amounts of unreviewed code in quickly. Treat the output like code from a new junior colleague: review it, test it and make sure it follows your conventions. If you add AI features to an app, also plan for their own maintenance; see How to add AI features to an existing app and Making AI features safe.

Three cards comparing fix as you go, health sprint and staged replacement

What does it cost to ignore it?

Ignoring debt is also a decision, and it has a price: slower delivery, higher defect rates, security exposure and staff turnover. For a sense of how this affects total spend, see The total cost of owning an app over five years. As a market estimate, not a quote, many teams find that ongoing maintenance and change work make up a large part of lifetime cost, so a codebase that is cheap to change is worth real money. Compare any repayment plan to the interest figure you calculated earlier.

What is a simple plan for the next 90 days?

Weeks Action Output
1 to 2 Run the one hour debt review and start a debt register Ranked list of areas and items
2 to 4 Measure lead time, release frequency and failure rate Baseline numbers
3 to 6 Commission an audit if three or more warning signs apply Costed findings and options
4 to 8 Fix the high cost, low effort items alongside features First visible improvements
6 to 10 Add tests around the most fragile area and automate the build Safer releases
8 to 12 Agree a standing allocation and a quarterly review Sustainable routine

Frequently asked questions

What is an example of technical debt?

A team copies the same payment code into three screens to meet a deadline. Later, a change to the payment provider must be made in three places, and one gets missed, causing a bug. Consolidating the code into one module repays the debt.

How much technical debt is normal?

Every active product has some. It becomes a problem when it noticeably slows delivery or causes frequent incidents. Many teams aim to keep debt work at 10 to 20% of capacity.

Who is responsible for technical debt?

The whole product team. Engineers should make debt visible and explain its cost; product owners should budget time to address it alongside features.

Does technical debt affect app store ratings?

Indirectly. Debt leads to bugs, crashes and slow updates, which users notice and review.

Can AI coding tools reduce technical debt?

They can help with refactoring, tests and documentation, but they can also add debt if generated code is accepted without review. Treat them as assistants, not replacements for good engineering practice.

How do I know if I need an audit?

If three or more of the warning signs above sound familiar, such as repeated underestimates, fear of changing certain areas or one person who holds all the knowledge, an audit will pay for itself. It also helps before changing supplier, raising investment or planning a major feature.

Is a rewrite ever the right answer?

Yes, when the technology is obsolete, the architecture blocks the product’s direction or nobody can safely change the code. Even then, a staged replacement is usually safer than a single big switch. An assessment of the current state should come first.

Official sources and further reading

Planning an app?

Talk it through with one of our co-founders. 30 minutes, no pressure.

Book a call