Buyer Guides · 7 MIN
How to take over a software project from another developer
Rescuing or handing over a stalled software project? Secure access first, audit the code, rebuild the documentation, and run a calm first 30 days before adding features.
Your developer has stopped replying, or the relationship has ended, and a half-built product sits somewhere you cannot quite see. Taking over a software project safely follows a fixed order: secure every account and the code first, audit what actually exists, write down how it works, and only then start changing it. Skipping straight to new features is the most common mistake, because nobody yet knows what is fragile. This guide walks through each step and a plan for the first 30 days.
- Access comes before everything. Domains, hosting, code, databases and third-party services must be in accounts you control.
- An audit tells you what you really have: whether it builds, whether it runs, and how risky it is to change.
- Missing documentation is normal in a stalled project. Rebuilding it is part of the takeover, not an optional extra.
- The first month is for stabilizing, not for features. Fix what is dangerous, then make the product easy to change.
- Rewriting from scratch is sometimes right, but only after an audit shows that repairing would cost more.
- Nactore is a technology and growth company that takes over, audits and rebuilds products, then ships, ranks and grows them as one partner.
What should you do first when a project stalls?
Stop work that depends on the old developer, and secure access. Before anyone touches code, find out where every part of the product lives and who controls it. If the outgoing developer is still cooperative, ask for a handover while goodwill lasts. If they are not, every hour matters, because accounts in their name can expire, be deleted or be held back in a dispute.
Check the contract too. It should say who owns the code and what the developer must hand over when the work ends. Our guide to IP and data terms covers the clauses to look for, and a lawyer can help if ownership is disputed.
Which accounts and assets must you secure?
Work through this list with the outgoing developer, or alone if you have to. Every item should end in an account you own, with your own login.
| Asset | What to secure | Warning signs |
|---|---|---|
| Domain | Registrar login in your name, auto-renew on | Domain registered to the developer's personal account |
| Code repository | Owner access to the repository or organization | Code only on the developer's laptop |
| Hosting and cloud | Owner or billing access to servers and services | Hosting paid on the developer's card |
| Database | Admin access and a fresh backup you hold | No backups, or nobody knows where they are |
| Third-party services | Payments, email, maps, analytics, AI providers | API keys tied to the developer's accounts |
| App store accounts | Apple and Google developer accounts in the company name | App published under the developer's account |
| Secrets and credentials | A full list, then rotate every key | Passwords stored in chat messages or the code |
If the code lives on GitHub under someone else's account, GitHub's guide to transferring a repository explains that issues, pull requests, history and secrets move with it, and that old links redirect. Once access is yours, rotate every password and API key, because you cannot know who still holds copies.
How do you audit the code you inherited?
An audit answers one question: is it safer to repair this product or to rebuild it? A practical audit covers:
- Does it build? Can a new engineer set it up from the repository and run it locally.
- Does it match production? Is the code in the repository the code that is actually live.
- Dependencies. Which libraries it uses, how outdated they are, and which have known vulnerabilities. CISA describes a software bill of materials as an inventory of the components that make up software, and producing one is a good first step.
- Security. Exposed secrets, missing access checks, unprotected admin pages. Our vibe-coded app security checklist covers the common gaps, whoever wrote the code.
- Data. The database structure, data quality, and whether backups exist and restore.
- Tests and structure. Whether any tests exist, and whether the code is organized well enough to change without breaking things.
The output should be a short written report with findings ranked by risk. For a deeper version, see what a software platform compliance and robustness audit covers.
Ask the incoming team to deploy one trivial change, such as a text edit, to production as their first task. If that takes days, you have learned the most important fact about the project.
What documentation should exist after the takeover?
Stalled projects rarely come with documentation, so the new team writes it as it learns. At minimum:
- A setup guide. How to run the product locally, step by step.
- A deployment guide. How a change reaches production, and how to roll it back.
- An accounts map. Every service, what it does, who owns it and what it costs. Our guide to technical setup for non-technical founders has a template.
- An architecture note. The main parts of the system and how data flows between them.
- Known issues. What is broken, fragile or unfinished, with the audit's risk ranking.
This documentation is what stops the next handover from being a rescue too.
What should the first 30 days look like?
The first month is about control and stability. Resist the pressure to ship the features that were promised before the project stalled.
Start of the month. Secure every account, take and test backups, rotate credentials, and get the product building from the repository. Set up error monitoring so you can see what users hit.
Middle of the month. Finish the audit, fix the critical security and data risks, and make deployments routine and repeatable. Write the setup and deployment guides as you go.
End of the month. Agree the repair or rebuild decision based on the audit, rank the backlog by risk and value, and ship the first small improvement users can see. From here, normal product work can resume.
Should you repair or rewrite?
Most of the time, repair. A working product, however messy, holds knowledge about real users and edge cases that a rewrite has to rediscover. Rewriting makes sense when the audit shows the code cannot be built or secured at reasonable cost, when the technology is abandoned, or when the product's direction has changed so much that little of the old code fits.
A middle route often works best: keep the product running, and replace its weakest parts one at a time behind the scenes, so users never face a big switch.
Frequently asked questions
What if the previous developer will not hand over the code?
Check your contract for ownership and delivery terms, and get legal advice. Meanwhile, secure every account you can still reach, especially the domain and hosting, and take backups of anything live.
Can a new developer work on code they did not write?
Yes, this is routine work for experienced engineers. Expect the first weeks to go into reading, setting up and documenting, before speed picks up.
How do I know if the old code is any good?
Commission an independent audit. A written report with ranked findings gives you a basis for decisions, instead of the new team's first impression.
Should the old and new developers overlap?
If the relationship allows it, yes. Even a short paid overlap for questions and a walkthrough saves the new team a lot of guesswork.
Take control first, then move forward
A stalled project is recoverable when you secure access, audit honestly and stabilize before building. Nactore is a technology and growth company that takes over and audits software, rebuilds what needs rebuilding, then ships, ranks and grows the product, so one partner carries it from rescue to growth.
Inherited a project that will not move? Book a free 30-minute call and we will start with the access checklist.
Want to apply this to your business?
Book a free 30-minute call. We will tell you what we would do first.