Software project rescue: how to get a failing project back on track

Software project rescue is the work of taking over a stalled or failing project and returning it to regular, predictable releases. It starts with access to the code and accounts, then an audit of the product and the way the work is run. We run the audit as our analysis phase. The audit decides whether the product is fixed, replaced part by part, or rewritten.
This guide is for founders and product owners whose project has missed its dates, lost its team, or stopped making sense to them. It covers the warning signs, the steps from access and audit to the first sprints, how to decide whether to fix, replace, or rewrite, what changes for an app built with AI tools, how to choose a rescue team, what a rescue costs, and what to write down so the next handover is not another rescue.
What software project rescue means
A rescue is a change of course on a project that already exists. Unlike a new build, it starts with someone else's code, half-finished features, and promises already made to users or investors. Its goal is a product that the owner understands, that releases on a known schedule, and that another team could take over again without starting from zero.
The work has three possible outcomes:
- Fix and finish: The new team fixes the worst problems and continues development on the same code.
- Replace part by part: New parts are built next to the old ones and take over their work one at a time.
- Rewrite: The team builds the product again, using the old one as a working specification.
Signs your project needs a rescue
A project needs a rescue when you can no longer tell where it stands. Delay alone is not the signal: a healthy project can also miss a date. The signal is that the dates, the budget, and the answers to your questions keep changing, and nobody can show you working software that explains why.
- No results you can open: Weeks pass between demos, or the demos are slides and screenshots rather than a build you can use yourself.
- Old bugs come back: A fix in one place breaks something in another, which is often a sign that the code has too few automated tests to catch it.
- The estimate only grows: Each new estimate is larger than the last, and the team cannot say what changed.
- Releases depend on one person: Only one developer knows how to build and deploy the product, and work stops when that person is away.
- You do not control the accounts: The repository, the cloud account, or the app store listing is registered to the vendor, and nothing in writing moves it to your company.
- Agreements live in calls: Scope changes were agreed by phone or in chat, and there is no written record of what is in the plan.
Two or three of these together are enough to ask for an outside audit. You do not have to fire anyone to get one: an audit tells you what you have, and you decide what to do with that answer.
Step 1: Secure access and documents before anything else
Before any audit, make sure your company controls access to its own product. A rescue team cannot judge code it cannot read, and you cannot change teams if the old one controls the accounts. This step costs little and protects every option you have, including staying with the current vendor.
Collect the following, and check that your company can access each one without the old team's help:
- Code: every repository, with full history, including the backend, the web and mobile apps, and the infrastructure code.
- Accounts: the cloud account, the domain, the app store developer accounts, and every paid third-party service the product calls, each registered to your company.
- Secrets: keys and passwords, handed over through a password manager and changed once the old team leaves.
- Design and specifications: design files, requirements, user stories, and any API documentation.
- The task tracker: the backlog, open bugs, and the history of what was promised and when.
A missing document is itself a finding, and it does not stop the work. In a troubled project, the most important knowledge may exist only in the old team's heads. Ask them to record how to build and release the product while they are still available, even in a short video.
Our own projects start in the client's cloud account, and the repository is created in the client's organization. When a client asks us to host the repository in our GitLab instead, our standard contract covers its transfer to the client, along with access.
Step 2: Audit the product, the code, and the process
The audit answers two questions: what state the product is in, and what it will cost to make it reliable. A good code audit looks at the code and at how the work was run, because a team that fixes the code but keeps the old process will end up with the same problems.

The audit should cover these areas and end with a written verdict:
- Build and release: whether the new team can build the product from the repository and release it without the old team's help.
- Code quality: how hard the code is to read and change, and where the high-severity bugs are.
- Tests: how much of the core logic automated tests cover, and whether those tests pass.
- Security: how the product stores and sends personal data, payments, and passwords.
- Architecture and infrastructure: whether the product can carry the load and the features on its roadmap.
- Process: how requirements were written, how changes were agreed, and how progress was reported.
“I read the commit history side by side with the task tracker. When the tracker marks a feature as done and the code shows it half-built, that is a process problem as well as a code problem.”
Alexander Storozhevsky, Lead developer at Ronas IT
Fix, replace part by part, or rewrite: how to decide
Choose the smallest change that makes the product safe to develop. Fixing in place keeps everything that already works; a rewrite throws away past fixes along with the bugs.
A full rewrite has a long record of going wrong. In 2000, Joel Spolsky called the decision to rewrite the code from scratch “the single worst strategic mistake that any software company can make”, using Netscape as his main example. The alternative that Martin Fowler and his colleagues prefer is the strangler fig approach: new code grows next to the old system and takes over its behavior piece by piece.
| Path | When it fits | Main risk |
|---|---|---|
| Fix and finish | Core flows work, tests can be added, the stack is still supported | Hidden problems the audit missed slow down the first sprints |
| Replace part by part | The product must stay live, and some modules cannot be saved | Old and new parts must work together for a long time |
| Rewrite | The code cannot be changed safely: serious bugs in core flows together with too few tests and security issues | The old product gets no new features until the new one is ready |
Sometimes the evidence points to a rewrite. A trading platform in Nigeria, which let users buy assets on the Nigerian stock market and invest in mutual funds, had worked with another development partner before it came to us. The client asked us for an audit of the mobile app and the backend. The audit found security vulnerabilities, high-severity bugs, complex code, and low test coverage, so refactoring would not have given the results the business needed, and we recommended a complete rewrite.
The client stayed with us for the rebuild. We simplified the interface, built the infrastructure on Kubernetes in AWS, and implemented identity checks through a local Nigerian service. Our fintech software development page describes the project.
Step 3: Decide what to keep from the old plan and write it down
After the audit, agree on a smaller, written scope before the new team writes code. A rescued project may not need everything the old plan promised. Go through that plan feature by feature: keep what users and the business depend on now, move the rest to a later release, and put the kept features in an order everyone has approved.
We run this step like the start of a new project, from a written kickoff plan that sets the features, their priorities, and the success criteria before work begins.
Each requirement then becomes a written ticket, so a changed request shows up as a change.
Step 4: Stabilize first, then deliver in short sprints
The first sprints after an audit fix what is dangerous, not what is visible: security holes, data loss risks, and the bugs that break core flows. New features come after that. Short cycles with results you can open are how a rescue team earns back the trust the project lost.

Each of our sprints, usually one to three weeks long, gives you a result to check yourself. Our guide to custom software project management covers the weekly reports, the milestone demos, and the decisions your side owns once the project is back on track.
Technical debt means shortcuts in the code that slow down later changes. We sort it by how it blocks work. Debt that blocks work now is fixed first, in the stabilization sprints; debt that will block the next features is planned; the rest waits. Larger items become separate tasks in a backlog, so the release plan does not stall on cleanup.
Inherited code also decides how fast it can safely change, whether a person or an AI agent makes the change. Addy Osmani suggests a map of zones for old codebases: well-tested, isolated parts where agents can work in tight loops; mixed parts where they change code only after characterization tests record what it does today; and sensitive parts, such as authentication, billing, and permissions, where a person takes part in every step. The map comes from a person who knows the code, not from the agent. Our engineers work on inherited code with AI agents too: they set each task and review and accept every change.
Rescuing an app built with Lovable, Bolt, Cursor, or another AI tool
An app built with an AI app builder usually needs a rescue for a different reason than a vendor project. Nobody missed a deadline: the app was made in days, works in a demo, and then has to accept real users, real data, and real payments. The gaps sit in the parts a demo does not test, so the audit checks these first:
- Authorization: sign-up and login work, but the app does not check what each signed-in user is allowed to do, so one user can open another user's records by changing an ID.
- Data access rules: an app built with Lovable or Bolt can keep its data in Supabase, where each table needs row level security policies that say who can read and write each row. Lovable's own Supabase documentation warns that “missing RLS policies are the most common way app data gets exposed”, and Supabase's guide states that a table in an exposed schema without row level security is readable and writable by any role with a grant on it.
- Payments: the checkout works in test mode, but the app may trust the browser to say a payment succeeded instead of confirming it on the server, and leave failed or refunded payments unhandled.
- No tests: every new prompt can change code that already worked, and nothing tells you which flow it broke.
- Deployment: the app may run only on the builder's hosting or on one person's machine, with secret keys stored in the code and no separate environment for testing changes.
- Monitoring: errors reach you as messages from users, because nothing records them in production.
A finding in the data access rules can be more than a bug. If real users' personal data was open to anyone, it may count as a personal data breach. Under Article 33 of the GDPR, the company that controls the data notifies its supervisory authority without undue delay and, where feasible, within 72 hours of becoming aware of a breach, unless the breach is unlikely to put people at risk. Bring in your lawyer as soon as the audit reports such a gap, and check the breach rules of the other places where your users live.
Our AI-built app rescue service covers the items on this list. We audit the code and its security, close the gaps in authorization, data access, and payments, then add tests, a proper deployment, and monitoring before the app takes real users. A rewrite is rarely the first choice here either: we keep the parts of the generated code that are stable and build on them. Features the app still lacks are priced like any other MVP work.
How to choose a software project rescue team
Choose the team that asks for access and an audit before it promises dates. A team that commits to the old roadmap on the first call has not seen your code. Ask each candidate the same questions and compare the answers on substance.
- “What do you need from us before you give a plan?” Expect a list of access and documents, then an audit with a defined scope.
- “Will you tell us if the code should be rewritten?” Expect criteria, not a default answer in either direction.
- “Where will the code and the accounts live?” The answer should be: with you, or with a contract that moves them to you on request.
- “What will we see, and how often?” Look for a written report every week and working results at the end of each sprint, on top of any status calls.
- “How would another team take over from you?” A team that plans for its own exit plans for documentation from the start.
“Listen to how a candidate talks about your previous vendor. Blaming the old team is easy, and it tells you nothing about your code. A team you can trust reads the code first and then talks about what it found.”
Roman Surikov, CEO at Ronas IT
How much a software project rescue costs
A rescue has two parts with different prices: the audit, and the work the audit calls for. An audit ordered on its own runs as our analysis phase: $1,000-$2,000, and takes at least one week. The work after it is estimated from the audit's findings and priced like any other development.
At Ronas IT, these are the common options for a rescue and for the support after it:
| Option | When it applies | Price |
|---|---|---|
| Dedicated development team | Two developers and a part-time project manager either take over and continue the product, with planning and reporting for a project that had none, or join your in-house team and work in your process | From $8,000 per month |
| CTO as a service, run as an analysis phase | You need technical direction, an audit, architecture, and a roadmap rather than a new team | $1,000-$2,000 per project, at least 1 week |
| AI-built app rescue | An app made with Lovable, Bolt, Cursor, or a similar tool has to be ready for real users | From $2,500 per project, at least 2 weeks |
| Support and maintenance | The product is stable and needs monitoring, fixes, and updates | From $1,000 per month for an app, from $2,000 for a whole system |
A rewrite is priced like a new build of the same product. For a product like the trading platform above, a regulated fintech build starts at $30,000 for one client platform, with the admin panel and backend included, and takes at least 10 weeks. Each extra platform, such as a web app next to the mobile one, adds from 50% of that.
What to document so the next handover is not a rescue
Part of the cost of a rescue goes into rebuilding knowledge that left with the old team: how the product works and why it was built that way. Keep a few records current during development, and another team can take over your product without an emergency.
- Written agreements: Every change to the scope, the dates, or the budget is confirmed in writing after the call where it was agreed.
- Requirements tied to code: On our projects, branch names start with the task ID, and each commit links back to its task, so you can trace any line of code to the requirement it serves.
- API documentation from tests: Every backend change on our projects comes with a described test case, and the API documentation is generated from the tests that pass, so it matches the current API.
- A release runbook: Step-by-step instructions to build, release, and roll back, kept in the repository.
- A handover checklist: A written list of what passes to the next team: repositories, accounts, runbooks, and open tasks. When a client moves the product to an in-house team, our structured handover takes 2 to 4 weeks and includes deployment runbooks and knowledge transfer.
- A second person for each critical system: For every system the product depends on, ask how many people could keep it running if the main one left tomorrow. An answer of one is a risk to fix, as Mike Fisher argues, not a fact to accept.
What to do next
- Check the warning signs above against your project and write down which ones apply.
- Confirm that your company owns the repository, the cloud account, and the app store accounts.
- Ask the current team to record how to build and release the product.
- Order an audit and ask for a written verdict: fix, replace part by part, or rewrite.
Frequently Asked Questions (FAQs)
What is software project rescue?
It is the work of taking over a software project that has stalled or lost the owner's trust and returning it to regular, predictable releases. A new team secures access to the code and accounts, audits the product, decides what to keep, fix or rebuild, and then delivers in short cycles the owner can check.
Is it better to rescue a software project or start over?
Start from the audit, not from a preference. Keep and fix the code when its core parts work and can be tested. Replace it part by part when the product must stay live during the change. Rewrite it only when the audit shows the code cannot be changed safely, for example because of serious bugs in core flows, too few tests, and security issues.
How long does a software project rescue take?
The audit comes first, run as our analysis phase: at least one week, whatever the size of the system. The work after it is estimated from what the audit finds, and its length depends on the verdict: fixing and finishing an existing product is a series of sprints, while a rewrite means building the same product again.
How much does a software project rescue cost?
Ordered on its own, the audit is done as our analysis phase, which costs $1,000-$2,000. After the audit, you pay for the work it calls for. At Ronas IT, a dedicated development team, with a part-time project manager, starts at $8,000 per month. A full rewrite costs as much as building that product from scratch: a regulated fintech product, for example, starts at $30,000 for one client platform.
Can a new team take over code that another company wrote?
Yes, if you can give the new team the repository and the accounts the product runs on. The new team should first check that it can build the product and release it on its own, and only then commit to dates.
What if the previous vendor does not hand over the code?
Read your contract first: who owns the code and the accounts depends on what it says, and a lawyer should check it if the vendor refuses. In the meantime, list every account the product runs on and who controls each one. Without the repository, a new team can only rebuild from the specifications and the live product.
Do I have to replace my current developers?
Not always. If your own developers know the product, they are the best source for the audit, and a rescue team can work next to them. If they need more people, our developers can join them as a dedicated team, from $8,000 per month. A full replacement makes sense when the old team has left or the trust is gone.
Can you rescue an app built with AI coding tools?
Yes. A prototype built with AI coding tools can run in a demo and still have hidden bugs, security gaps, and code that is hard to change. The rescue follows the same steps: access, audit, then a plan. Our AI-built app rescue starts from $2,500 and covers the audit and the fixes an app needs before it takes real users and payments.







