Software project rescue: what to do when your vendor is failing
How to tell drift from failure, run a two-week audit, and choose between fixing the engagement, restructuring it, or switching vendors without losing the work.
When a software project is drifting, do three things in order: stop accepting narrative in place of evidence (working software, shown running, every cycle); commission a short independent audit of the code and the real state of delivery; then choose between three options the audit will make obvious - fix the engagement, restructure it, or execute an orderly handover to a new team. What kills projects is not the drift itself but the months spent hoping instead of measuring. Here is how to run each step.
How do you tell normal turbulence from real failure?
Every project has bad sprints. The distinction is direction of information: healthy projects surface bad news early and voluntarily; failing ones make you discover it. The reliable signals:
- Demos die. Working software gives way to slide decks and percent-complete numbers. Software that exists gets shown; software that gets described instead usually doesn’t.
- Estimates reset rather than converge. Each re-plan starts fresh and lands the same distance away. Honest teams miss estimates too - but their misses shrink and come with explanations.
- “Done” that can’t be exercised. Features marked complete that no one can click through today, in a test environment, end to end.
- Silent staffing changes. Key people vanish from calls; replacements arrive without hand-over. Ask directly who is on the team this month.
- Defensive answers. Technical questions returned as reassurance (“don’t worry, it’s handled”) rather than substance.
One signal is a conversation. Three or more mean the reporting you receive no longer describes the project - and your next decisions need evidence from outside that reporting.
Step one: switch from narrative to evidence
Before any bigger move, change what you accept as truth. Require a running demo of real functionality every cycle, in an environment you can access. Require the code - in a repository you control, with the build reproducible outside the vendor’s laptops (your contract’s IP and infrastructure clauses are what make this demand routine rather than dramatic). Require a re-baselined plan that explains what changed since the last one.
A capable vendor in temporary trouble responds with visible relief - structure helps them too. Resistance to showing the running software is the single most diagnostic response in this entire process.
Step two: commission a short independent audit
You cannot choose between fixing and leaving without knowing what actually exists. An independent audit - one to three weeks, by people not invested in the project’s story - reads the code, the tickets, the delivery history and the contract, and answers four questions in writing:
| Question | Why it decides everything |
|---|---|
| What is actually built, at what quality? | Sound-but-slow and broken-but-fast need opposite remedies |
| What genuinely remains? | Re-estimated bottom-up, not from the vendor’s percentages |
| Where is the failure rooted? | Requirements, skills, management, or trust - each has a different fix |
| What are the options, priced? | Fix, restructure, or transition - with cost and risk for each |
Expect the uncomfortable finding, too: a meaningful share of audits locate part of the problem on the client side - unclear requirements, an absent product owner, decisions queued for weeks. That is good news, because your side of the process is the part you can fix by Monday.
Step three: choose - fix, restructure, or transition
Fix the engagement when the code is sound and the people are capable but the process failed: vague scope, no demos, missing product ownership. Re-baseline honestly, install the evidence habits from step one, name a real product owner on your side, and give the reset 4–6 weeks with explicit criteria. This is the cheapest path and it works more often than mid-crisis anger suggests.
Restructure it when the model is the problem more than the people: an endless fixed-price contract renegotiated monthly, or unmanaged T&M burning amiably in all directions. Convert to the engagement model that fits the work’s real shape, often with a smaller, more senior team - throughput usually rises when coordination overhead falls.
Transition when quality is the root cause or trust is unrecoverable. Bad foundations compound: every month of new features on broken architecture raises the eventual bill. A managed takeover looks like this: the incoming team audits and stabilizes first (tests around current behaviour, reproducible build and deployment), resumes feature work incrementally - the same discipline as legacy modernization, because that is what a troubled codebase is - while the outgoing vendor serves its contractual hand-over during notice. Done deliberately, the slowdown is weeks. Done in anger, months.
What should you do differently next time?
Rescues teach the same lessons with expensive tuition: evidence-based reporting from day one, contract exit terms you could actually execute, code in your own repositories from the first commit, and a pilot before any large commitment - because every failure mode described above is visible in miniature within a month, if you look.
In short
- Failure announces itself: no demos, resetting estimates, un-exercisable “done”, silent staffing churn, defensive answers.
- First move: evidence over narrative - running software every cycle, code in your repository, an honest re-baseline.
- Second: a 1–3 week independent audit - what exists, what remains, where the failure is rooted, options priced.
- Third: fix (sound code, broken process), restructure (wrong model), or transition (broken quality or trust) - decided by the audit, not by sunk cost.
- The prevention list is short and cheap: evidence habits, executable exit clauses, your infrastructure, a pilot.
AD System Asia performs independent project audits and managed takeovers from Bangkok - including telling you, in writing, when your current vendor deserves a second chance. If a project of yours is drifting, describe the situation.
Frequently asked questions
What are the warning signs that a software project is failing?
Demos replaced by status decks, 'done' work that can't be shown running, estimates that reset instead of converge, staff rotating without hand-over, and questions answered defensively. Any one is a concern; three or more mean the plan you are shown no longer describes the project.
What is a software project audit and how long does it take?
An independent review of the code, the backlog, the delivery history and the contract - typically one to three weeks - producing a written verdict: what is actually built and at what quality, what remains, and realistic options from here with costs and risks for each.
Should I switch vendors on a troubled project or try to fix the engagement?
Fix first when the work is sound but the process is broken - clearer scope, a real product owner, honest re-planning often recovers it. Switch when code quality is the problem or trust is gone: bad foundations compound, and a transition done deliberately costs less than a year of hoping.
Can a new vendor take over an existing codebase?
Yes - takeovers are routine for experienced teams. The new vendor audits the code, puts tests around current behaviour, stabilizes the build and deployment, then resumes feature work incrementally. Expect a slowdown of weeks, not months, if the hand-over is managed.
How do I protect the work already paid for when leaving a vendor?
Exercise the contract: IP assignment, repository and account hand-over, documentation and knowledge-transfer obligations, transition support during notice. This is exactly why exit clauses and client-controlled infrastructure should be agreed before a project starts - mid-crisis is the worst time to negotiate them.