Taking Over a Failed Software Project: The First 30 Days
November 11, 2026 · 8 min read · Etzal Group Team
Eighteen months and most of the budget are gone. The system does some of what was promised. The vendor has stopped answering, or the contract has been ended in anger. Inside the company, the project has become the thing nobody wants to own. This is the moment many businesses call a second vendor and ask, "can you finish it?" The honest answer to a failed software project is never immediate. It comes after thirty days of structured work.
Before anything else: stop the losses
Secure what you own. In the first days, obtain:
- The source code, as a complete repository with history, not a zip file of the latest version.
- Credentials for servers, cloud accounts, databases, domains, email services, payment and messaging providers, app store accounts.
- The production database and recent backups.
- Documentation, however thin: requirements, designs, deployment notes.
- Licences and accounts registered in the vendor's name that should be in yours.
Check the contract for what you are entitled to. If the departing vendor is still cooperative, ask for a handover session and record it. If not, get what you can and take advice on the rest.
Change the keys. Once you hold the credentials, rotate passwords and access keys, and remove accounts that should no longer exist. Do it carefully, so nothing in production breaks.
Keep the system running. If people depend on it, stability comes before improvement. Confirm backups work by restoring one. Find out who can restart it at 02:00.
Stop new feature work. Until the assessment is done, change only what is necessary to keep things running.
Days 1 to 10: assess
An assessment answers one question: what do we actually have? Look at five areas.
1. What works, from the user's point of view
Sit with real users. Go through each process the system was meant to support.
- Which functions work reliably?
- Which work with workarounds?
- Which do not work or do not exist?
- What do people do outside the system because of this?
Make a list in three columns: works, partly works, missing. This is often the first honest inventory anyone has made.
2. The code
- Can it be built and run from the repository by someone new, following written steps?
- Is the structure understandable, or is logic scattered and duplicated?
- Are there automated tests? Do they pass?
- How old are the frameworks and libraries? Are any no longer supported?
- Are there secrets in the code?
3. The data
- Is the data model sensible for the business?
- Is the data itself consistent: duplicates, orphans, impossible values?
- Is there data in production that the business now relies on?
A sound data model with messy code is far easier to rescue than tidy code on a wrong data model.
4. Infrastructure and operations
- Where does it run, and who pays?
- Is deployment a documented procedure or one person's memory?
- Are there backups, monitoring, logs?
- Are development, test and production separate?
5. Security
- How are users authenticated and what can each role do?
- Is sensitive data protected?
- Are there obvious holes: default passwords, open ports, unpatched components?
The other half: why it failed
Technology is rarely the only cause. Ask, without assigning blame:
- Were requirements clear and stable?
- Was there one person on the client side with authority to decide?
- Were users involved before the end?
- Was progress measured by working software or by reports?
- Were payments tied to results?
If the same conditions remain, a new vendor will reach the same place. Part of the rescue is changing how the client side runs the project.
Days 11 to 15: decide
The assessment leads to one of four paths.
Repair. The foundations are sound. The work is fixing defects, finishing features, adding tests and establishing a proper process. Fastest and cheapest when it applies.
Repair and replace parts. Most is usable. One or two components, such as a reporting module or an integration, are rebuilt. The most common outcome.
Rebuild, reusing what can be reused. The foundations are wrong. A new system is built, keeping the data, the requirements learned, and any components worth saving. Costly, and sometimes the only honest answer.
Stop. The need has changed, or a ready-made product now covers it. Accepting the loss is better than adding to it.
How to choose:
| Finding | Points toward |
|---|---|
| Data model fits the business, code is messy | Repair |
| Code builds and runs, tests are missing | Repair, add tests first |
| One module is the source of most problems | Replace that module |
| Data model cannot represent how the business works | Rebuild |
| Unsupported technology nobody can maintain | Rebuild, or migrate the platform |
| No source code available | Rebuild |
| The business process itself has changed | Re-scope before either |
Beware the urge to rewrite everything. A new team almost always prefers its own code to someone else's. A rewrite discards working behaviour along with the bad, takes longer than estimated, and delivers nothing until late. Ask any vendor proposing a full rewrite to show specifically why repair cannot work.
Beware sunk cost too. What was already spent is gone whichever path you choose. The only question is which path costs least from here to a system that works.
Days 16 to 30: restart
Re-scope
Go back to what the business needs now, which may differ from the original brief.
- From the three-column list, mark what is essential for the system to be useful.
- Cut everything else from the first phase.
- Define a first release that is small and valuable: one process, end to end, working properly.
Rebuild trust with a visible win
After a failure, people have stopped believing dates. The cure is delivery.
- Choose something users complain about daily that can be fixed in two weeks.
- Fix it, release it, and let them use it.
- Then the next.
A sequence of small releases every two or three weeks does more for confidence than any plan.
Put foundations under the work
In parallel with the first fixes:
- A repository the client controls.
- A documented way to build and deploy.
- Separate test and production environments.
- Tests around the most critical functions before changing them.
- Backups verified by restoring.
- A simple log of defects and requests.
Change how the project is run
- One decision maker on the client side.
- Demonstrations of working software every two weeks.
- Payments tied to accepted releases.
- Written acceptance criteria before each piece of work.
- A change process.
- Users involved in every review.
Working with the previous vendor
Even after a bad ending, a civil handover is worth pursuing.
- Ask for a paid handover period if they are willing.
- Request specific things: repository access, credentials, a walkthrough of deployment, known issues.
- Keep communication factual and in writing.
- Settle what is contractually owed on both sides, with advice.
A day of the original developer's time can save the new team weeks.
What to tell the organisation
Be straightforward:
- What the assessment found.
- What will be kept and what will be redone.
- What the first release contains and when.
- What has changed in how the project is managed.
Avoid promising the original scope by a new date. Promise the first release, deliver it, then promise the next.
Common mistakes
- Hiring a new vendor to "just finish it" without an assessment.
- Rewriting from scratch by default.
- Keeping the same project governance.
- Not securing code and credentials early.
- Continuing to add features to an unstable system.
- Blaming individuals, which makes people hide information the rescue needs.
- Setting another big-bang date.
A paid assessment first
For both client and incoming vendor, a short fixed-price assessment is the safest start. It produces the three-column inventory, findings in the five areas, a recommended path with reasons, and an estimate for the first release. The client can take that report to anyone.
We do this kind of assessment and the work that follows as part of Enterprise Software. If you have a system in this state, contact us and we will tell you what we would look at first.
Summary
Secure code, credentials, data and backups, and keep the system stable. Spend ten days assessing what works for users, the code, the data, operations and security, and why the project failed. Choose repair, partial replacement, rebuild or stop on the evidence, resisting both the full rewrite and sunk cost. Then re-scope to a small first release, deliver visible fixes every few weeks, lay proper foundations and change how the project is governed.
Frequently asked questions
Should a failed software project be repaired or rebuilt from scratch?
It depends on what the assessment finds. If the architecture is sound and the problems are bugs, missing features and poor process, repair is usually faster and cheaper. If the foundations are wrong, such as a data model that cannot support the business or code nobody can safely change, a rebuild of the affected parts is justified. A full rewrite is rarely the right first answer.
What should we secure first when a vendor relationship ends?
Access and assets: the source code repository with full history, credentials for servers, databases, domains and third-party services, the production database and backups, and any documentation. Get these before the relationship deteriorates further, and change passwords as soon as you hold them.
How long does it take a new team to become productive on an inherited system?
For a mid-sized business system, expect two to four weeks before a new team can make changes with confidence, longer if there is no documentation and no automated tests. A short paid assessment before committing to a plan reduces this risk for both sides.
Related service
Free consultation
Not sure where to start? We will map the right system for your business, free.
