Build log/Working with us

How to take over a stalled or failed software project

Secure access to everything first, then commission a code and infrastructure review. Choose between stabilising, refactoring and rebuilding on what the review finds.

The short answer

  • The first step in taking over a stalled project is securing access to the code, hosting, data, domains and app store accounts, before anything else changes.
  • A code and infrastructure review tells you whether the software builds, what state the data model and security are in, and what each option would cost.
  • Stabilise when the foundations are sound, refactor when the problems are local, and rebuild only when the data model or technology no longer fits the business.

To take over a stalled or failed software project, first secure access to the code, infrastructure, data and accounts, then have an independent developer review what exists before you decide whether to stabilise, refactor or rebuild. A stalled project is one where development has stopped, or slowed so much that the software is not delivering what was paid for, often because a supplier has left, run out of budget or lost control of the code. The review is what turns a frustrating situation into a decision you can cost.

Secure access before anything else

When a relationship with a developer or agency ends badly, access is the most urgent problem and the easiest to lose. Ask for everything in writing, and change passwords and keys once you have control. You need all of the following.

  • The source code repository, including its full commit history.
  • Hosting and cloud accounts, including the database, file storage and backups.
  • The domain registrar and DNS.
  • Apple Developer Program and Google Play Console access. For Android, find out who holds the upload key used to sign releases. If the app uses Play App Signing, Google holds the signing key and a lost upload key can be reset on request.
  • Third-party services such as payments, email sending, SMS, maps and AI providers.
  • Environment variables and secrets, the deployment pipeline and any servers someone logs into by hand.
  • Error monitoring, analytics, the issue tracker and design files.
  • The contract, the specification and any written agreement about ownership.

If an account is in someone else’s name, ask for it to be transferred or for you to be made an owner. Check the contract to see whether the copyright in the code was assigned to you. Our guide to who owns the code explains why that matters.

What a code and infrastructure review covers

A review is an independent assessment of the software, its hosting and how changes reach users, written up with findings and costed options. It should answer the questions in this table.

AreaWhat the reviewer checksWhat a good answer looks like
BuildWhether the software builds and runs from a clean copy of the repository using the documentationA new developer has it running locally on their first day
CompletenessWhat works against the specification, and what is missing or fakedEach feature marked as done, partial or missing
Data modelWhether the database structure matches how the business worksTables and relationships that someone in the business would recognise
Code qualityStructure, duplication, consistency and testsClear modules, with tests on the rules that matter
DependenciesVersions of the language, framework and packages, and known vulnerabilitiesSupported versions, no critical known vulnerabilities
SecuritySign-in, permissions, secrets and the handling of personal dataPermissions checked on the server, no secrets in the code
InfrastructureWhat is running, who pays for it, backups and environmentsInfrastructure described in code, backups restored in a test
DeliveryHow changes reach productionAn automated pipeline that anyone on the team can run

Red flags to look for

Some findings change the decision on their own. Price any of these into your options.

  • The code cannot be built from the repository, or the repository has no history.
  • Passwords, API keys or private keys are committed in the code.
  • The production server has been edited directly, so the live system no longer matches the repository.
  • There are no backups, or nobody has ever restored one.
  • The framework or language version is past its end of life and no longer receives security fixes.
  • Permissions are enforced only in the user interface, so the API returns data to anyone who asks for it.
  • Business rules, such as pricing or tax, are copied into several places and disagree with each other.
  • Important accounts are tied to one person’s personal email address.

Stabilise, refactor or rebuild

There are three broad options, and most takeovers use a mix of them.

Stabilise

Stabilising means making the existing software safe and dependable without changing its structure. Typical work includes fixing the build, adding monitoring and backups, patching vulnerabilities, writing tests around the most important behaviour and setting up automated deployment. It is the right first step in almost every takeover, because it reduces risk and buys time while you decide what else to do.

Refactor

Refactoring means improving the internal structure of code without changing what it does, one area at a time. It suits software whose foundations are sound but whose code has become hard to change. Users keep working throughout, and each improvement can ship on its own.

Rebuild

Rebuilding means writing a new system and moving users and data across to it. It makes sense when the data model is wrong for the business, when the technology is obsolete, or when so little works that there is nothing worth keeping. Rebuilds tend to take longer than expected, because the old system contains rules that nobody wrote down, and the data still has to be migrated. A common approach is to replace one part at a time, with the old and new systems running side by side until the old one can be switched off.

How to decide

Put the options side by side against the same questions. Working through them in order usually makes the answer clear.

  1. Does the data model fit the business? If it does, the code on top of it can usually be improved. If it doesn’t, every new feature will fight it, and a rebuild of at least the data layer is likely.
  2. Are the core rules correct? Check pricing, tax, permissions and anything involving money against real examples from the business.
  3. Is the technology supported? A framework that still receives security updates can be upgraded in steps. One past its end of life sets a deadline.
  4. Are there live users and data? Live users make a rebuild slower and riskier, because data has to be migrated and nobody can be left without a working system.
  5. What does the next year of changes cost under each option? Compare the cost of building your planned features on the existing code with the cost of a rebuild plus those same features.

Write the decision down with the reasons. If the situation changes, such as a larger customer arriving or a framework reaching end of life, you can revisit it with the same evidence.

Protecting yourself next time

Much of the damage in a failed project comes from losing visibility and control, and both can be designed in from the start. Keep every account in your company’s name and give the supplier access to it, instead of the other way round. Ask for access to the repository from the first week, so you can see work arriving. Pay against working software deployed to a test environment you can use, rather than against documents or estimates of progress. Agree a handover checklist in the contract, as described in what a proper handover includes, and test it before the final payment.

When you choose the next supplier, ask how they report progress, who owns each account and what happens to the code if the relationship ends. Clear answers to those three questions prevent most of the problems in this article.

Inherited a project that has stalled? Secure the access and get a review before committing to a rebuild. Talk to us about it.

Questions people ask

Should I rebuild a failed software project from scratch?

Only when a review shows that the data model or technology no longer fits, or that too little works to be worth keeping. Rebuilds take longer than they appear to, because the old system holds rules nobody documented. Stabilising first, then refactoring or replacing one part at a time, is usually the lower-risk route.

What if the previous developer will not hand over the code?

Check your contract first, to see what it says about ownership and handover. If copyright was assigned to you, you are in a strong position to demand the code, and if it was not, your rights may be limited to an implied licence. Take legal advice before escalating, and secure every account you already control in the meantime.

Can a new developer work with code written by someone else?

Yes, and it is routine. Software written in a mainstream language and framework, with a repository and some documentation, can be taken over by any competent team. The review tells you how much work it will take to get comfortable with it.

What is technical debt?

Technical debt is the extra cost of future changes caused by shortcuts taken earlier, such as missing tests, duplicated logic or outdated dependencies. Like financial debt, a little can be a sensible way to ship sooner. A stalled project often carries so much of it that every change is slow and risky.

Written by Flavoureak

We build and run Estimark, CurioKids and CalcStack, and we build web and mobile software for other businesses. Start a project.