How do you take over a software project from another developer?
Get access to everything and check who owns each account. Then run the app from a clean copy, read how it deploys, trace the flows that make money and rank the risks before changing anything. I do this as a fixed 14 days for $995: findings in the first 5 business days, then the fixes that fit.
In a study of 133 popular GitHub projects, 65% depended on one or two developers: if those people left, the project would stall. The study covers open source projects in 2016, not client apps, but the pattern is the reason takeovers exist.
From my work
Most of my projects started with someone else’s code: Itmatched and Mom Software, for example.
When I reviewed one client’s app, the code was well written, with a clean separation of concerns. I gave it 8 out of 10. The missing points were types: it was plain JavaScript, on a project big enough to get messy fast. Later the client noticed a spike in the AWS bill. I followed it in CloudWatch and found PostgreSQL queries hitting an old logs table of more than 24 GB, so I partitioned it by quarter.
At Mom Software the Angular 10 app followed no pattern and carried dead code and unused libraries. We stopped patching it, started again on a clean base and moved the old code across module by module. That work also removed insecure third-party libraries and hard-coded keys.
When Itmatched reached me, its MVP already had years of code behind it and was not live. After we fixed and migrated the legacy code, we went to production on time.
What a takeover is
A takeover is when a new developer becomes responsible for software someone else built: the code, the hosting, the releases and the fixes. The product stays live while that happens.
A rescue is the same job on a worse day: the project has stalled or is failing. A takeover can be a healthy product whose developer simply moved on. The first steps are the same either way.
What I need from you
Access, read-only to start. If something on this list is missing or sits in someone else’s name, do not hold the start for it. I write it down as the first finding and we carry on.
- The code repository, with its history.
- The hosting or cloud account, and the database.
- The domain and DNS.
- App store accounts, if there is a mobile app.
- Payment, email and other outside services the app talks to.
- The build and release pipeline, and any monitoring.
- Whatever documents exist. Often there are none, and then the code and the running app have to do the talking.
The first 14 days
For the first 5 business days I read and change nothing. I list the accounts, run the app from a clean copy, follow a release from start to finish and use the product the way a customer does. Then you get the findings ranked by risk, each with where it is, what to change and a rough effort.
The days left go to fixes, in the order you choose. I put a test around a flow before I change it. I also ship at least one small change through your real release path, so the deploy stops being a thing only one person has ever done.
It ends with a written plan for the rest and a walkthrough call.
The numbers as text
- List every account and who owns it: Repo, hosting, domain, database, payments. Flag any in the old developer’s name.
- Check the backups: Confirm they exist, what they cover and when one was last restored.
- Run it from a clean checkout: Build the app from scratch and write down the setup steps.
- Read how it deploys: Who can release, how, and how to roll back.
- Trace the flows that make money: Sign-up, payment and the core action, used the way a customer would.
- Check versions and secrets: Which frameworks still get security fixes, and whether keys sit in the code.
- Findings by business day 5: Ranked by risk: where it is, what to change and a rough effort.
- Fix the top risks that fit: Security holes, broken deploys and missing backups come first.
- Test before touching a money flow: Record what it does today, then change it.
- Ship one small change: Through the real release path, so the deploy is proven by someone new.
- Written plan and a call on day 14: What to keep, what to fix next, and what to rebuild in parts, if anything.
Cite as: badii.studio, "The first 14 days of a takeover", https://badii.studio/project-takeover#first-14-days-of-a-takeover
You rarely have to rebuild
Ask a new developer about the old code and you will often hear that it all has to go. Developers say this the way plumbers look at the last plumber’s pipes. Usually it does not have to go. Joel Spolsky explained the reflex back in 2000: "It’s harder to read code than to write it."
My default is to keep what works and replace a part only when fixing it costs more than building it again. Martin Fowler describes the same idea as replacing an old system gradually, piece by piece, while it keeps running.
If a part does need replacing, I show you the evidence and say why. You decide.
If the last developer will not help
Then the code and the running app are the documentation. It takes longer. The list of accounts matters more too, because nobody is left to mention the one forgotten service that the whole checkout quietly depends on.
I do not need the previous developer to be available. It does help if they answer questions for a week or two, so ask for that while the two of you are still on good terms.
Who owns the code and the accounts
Who owns the code depends on your contract with the developer or agency who wrote it. That is a legal question, so read the contract or ask a lawyer.
The accounts are simpler. The repository, hosting, domain and payment accounts should be in your company’s name, with you as an owner. GitHub recommends at least two owners on every organization, because with one owner the projects can become unreachable if that person is.
With me, everything lives in your repository and your accounts from the first day.
What 14 days gives you, and what it does not
- You get: a clear picture of who controls what, the risks in order, the first fixes shipped, and a plan with rough effort for the rest.
- You do not get: someone who knows every corner of a large system. That takes anyone longer than two weeks, and nobody has measured how much longer.
- After the 14 days you can stop, hand the plan to another developer, or keep me on a monthly plan.
What it costs
- 14-day Trial: $995, one time. The audit, the fixes that fit in the 14 days, a written plan and 1 walkthrough call.
- If the audit in the 14-day Trial doesn't find at least 5 concrete, actionable issues, the Trial is free.
- Fee credited to your first month if you start a monthly plan within 14 days of the Trial ending.
- Limited plan: $1,995 a month. One task at a time, a day of work delivered within 2 to 3 working days.
- Full plan: $4,995 a month. One task at a time, worked on every working day.
Read next
Sources
- Avelino et al., A Novel Approach for Estimating Truck Factors (ICPC 2016), read 17 Nov 2026
- GitHub Docs, maintaining ownership continuity for your organization, read 17 Nov 2026
- Joel Spolsky, Things You Should Never Do, Part I, 6 Apr 2000
- Martin Fowler, Strangler Fig, 22 Aug 2024