Software Project Rescue: Taking Over From a Vendor
Rescuing a failing software project: the warning signs, two weeks of access, audit, build and triage, rewrite versus repair, and getting your code back.
A software project rescue is the work of taking over a failing build from another vendor: recovering the code, credentials and infrastructure, finding out what state the software is in, and getting a working release out again before deciding what to rebuild. Done well, the first two weeks produce full access, a written code audit, a build that runs from the repository, and a triage list that turns a vague sense of trouble into priced items. Most of the projects we are asked to rescue at RNDSOL did not fail on technology. They failed on visibility: months of status reports that said 'on track' with no demo, code that lived on the vendor's servers, and a client that found out about the problem at the deadline. That is recoverable in most cases, and a rewrite is needed less often than the frustrated client expects. The sections below cover the warning signs, the first two weeks, how to get your assets back from a vendor who may not cooperate, and how to choose between repair and rewrite. If you are still choosing a replacement vendor, our custom software development page explains how we start one.
What Are the Warning Signs a Software Project Is Failing?
- No working demo in the last month, only status reports and screenshots
- The code sits in the vendor's repository, and you have never had access to it
- Dates move every sprint, a week or two at a time, with a new reason each time
- Bugs you reported months ago come back after being marked fixed
- The team changes often, and new engineers spend weeks getting up to speed
- Nobody can deploy except one person at the vendor
- Change requests are priced high and answered slowly, even for small changes
- Answers to technical questions get shorter and vaguer
- The test: two of these at once justify an independent code review, and four justify planning the switch
What Happens in the First Two Weeks of a Rescue?
- Days 1 to 3, access: repositories with full history, cloud and hosting accounts, the domain registrar and DNS, app store accounts, third-party API keys, the database and its backups, and the issue tracker, all moved to accounts you own
- Days 2 to 6, code audit: read the core modules, list dependencies and their versions, check for tests, find hard-coded secrets, and compare what was built with what the contract and the backlog say was built
- Days 4 to 8, a working build: get the system building and running from the repository on a clean machine, then deploy it to a staging environment you control, which often uncovers missing configuration, unrecorded manual steps and code that exists only on a server
- Days 8 to 10, the triage list: every known defect, gap and risk, each sized in engineer-days and sorted into fix now, fix before launch, and later
- Day 10, the decision meeting: repair or rewrite for each part of the system, a revised plan in two-week sprints, and a priced first release
How Do You Get Your Code and Credentials Back From a Vendor?
Start with the contract. Most development contracts say who owns the code and when ownership transfers, often on payment, and many include a handover clause; read both before you tell the vendor you are leaving, and settle any undisputed invoices, because an unpaid balance is the most common reason a vendor holds code back. Then ask in writing for a specific list: the full repository with history, not a zip of the latest files; database dumps and backups; infrastructure and deployment scripts; every credential and API key; app store and domain transfers; design files; and documentation. Give a date. Where the vendor controls accounts that should have been yours, such as the cloud account, the app store listing or the domain, transfer those first, because they are the ones that can take the product offline. Rotate every password and key on the day you take control, since former team members still know them. If the vendor will not cooperate, a lawyer's letter citing the IP clause usually resolves it. If the code cannot be recovered at all, a copy of the production server is a poor starting point, and the project becomes a rewrite by default. The software development contract checklist lists the clauses that stop this happening on the next project, starting with code in your repositories from the first commit.
Should You Rewrite or Repair a Failing Project?
Repair is the default, and the audit should have to argue you out of it. A rewrite throws away the business rules embedded in the code, including the ones nobody wrote down, and restarts the clock on a project that is already late. Repair makes sense when the core data model is sound, the framework is current or one upgrade away, and the defects cluster in a few modules. Rewriting a part makes sense when one module is beyond saving, such as a payments or reporting component with no tests and logic nobody can explain, and it can be replaced behind the same interface while the rest keeps running. A full rewrite is justified when the data model is wrong for the business, the stack is unsupported, or the code cannot be built at all. Our legacy monolith migration for a logistics operator shows the middle path at scale. The two developers who understood the system had left, so the first two weeks went on reading code and tracing batch jobs, and the team then replaced the system one capability at a time behind an API gateway while it kept serving eighteen warehouses. An undocumented stored procedure holding contract-pricing logic turned up during cutover, which is exactly the kind of rule a clean-slate rewrite would have lost.
What Does a Software Project Rescue Cost?
The assessment is the cheap part. Two weeks of one or two senior engineers covering access, audit, build and triage costs $2,800 to $8,800 at $1,400 to $2,200 per engineer-week, and it is worth buying on its own, from someone who is not bidding for the rest. Stabilization comes next: fixing the defects that block a release, adding tests around the core flows, and setting up a deployment pipeline you own. On the projects we see, that is commonly 4 to 10 engineer-weeks, or $5,600 to $22,000, depending on how far the build drifted. Only then should the remaining scope be priced, and it should be priced from the triage list rather than from the original vendor's plan, which has already been wrong at least once. Accept that some of the money already spent is gone. The sunk cost is a poor guide; what matters is what the remaining work costs from here, compared with the value of shipping. Delivery then runs in two-week sprints with a demo at the end of each, so you see working software every fortnight instead of a status report, which is the habit that would have caught the original failure early. Our post on two-week sprints vs big-bang delivery explains why.
Rescue Checklist for the Week You Switch Vendors
- Read the IP, payment and handover clauses before you give notice
- Settle undisputed invoices so the handover has no excuse to stall
- Request the repository with full history, database backups, scripts, credentials and documentation in writing, with a date
- Move the cloud account, domain, DNS and app store listings to accounts you own first
- Rotate every password, API key and token once you have control
- Commission a two-week assessment from someone who is not bidding for the rebuild
- Get a working build deployed to staging before anyone estimates new features
- Price the remaining work from the triage list, not the old plan
- Default to repair, and require the audit to justify any rewrite module by module
- Put code in your own repositories from the first commit of the new engagement
Have a project that needs this kind of thinking applied to it?