If your developer or agency has gone, spend the first 48 hours securing control, not changing code. Confirm that your company owns the code repository, hosting, database, domain and every paid account the app uses. Remove the departed person's access, take a fresh backup and prove it restores, and write down how the app is deployed. Do not deploy, upgrade or "clean up" anything until a new team can build the app from a clean copy of the code.
Most apps that get stranded are not lost because the code was bad. They are lost because the only person who held the keys walked away with them. The checklist below is ordered by risk: access first, recovery second, knowledge third.
Hours 0 to 12: make sure you are in control
Start with an inventory. For each item, you want to be able to say: this account belongs to our company, and at least two of our own people can log in.
| What | Where it usually lives | What "owned by you" looks like | Red flag |
|---|---|---|---|
| Code repository | GitHub, GitLab, Bitbucket | Your organisation owns the repository; you are an owner, not a guest | It sits in the developer's personal account |
| Hosting and cloud | AWS, Google Cloud, Azure, DigitalOcean, Heroku, Vercel | The account is in your company's name and billed to your card | The bill goes to the developer, who re-invoices you |
| Database | Usually inside the hosting account | You can log in and take a backup yourself | Only the developer has the password |
| Domain and DNS | A registrar such as GoDaddy or Namecheap, DNS at Cloudflare or the registrar | The domain is registered to your company | The registrant is the developer or their agency |
| App store accounts | Apple Developer, Google Play Console | Your company is the account holder | The app was published under the developer's account |
| Payments | Stripe or another payment provider | Your company is the account owner | Payouts or API keys are tied to someone else |
| Email and SMS sending | Amazon SES, SendGrid, Mailgun, Twilio | The account and API keys are yours | You do not know which service sends your emails |
| Other paid APIs | Maps, AI models, search, analytics | Each one is billed to you | You find out about them only when something breaks |
| Error tracking and monitoring | Sentry, Datadog, uptime checkers | You receive the alerts | Alerts still go to the person who left |
If anything is in the developer's name, ask them in writing to transfer ownership now, while the relationship is still workable. Most people will, especially when asked early and politely. A tip that saves hours: your bank and card statements list every service the app pays for, including the ones nobody told you about.
Hours 12 to 24: lock the doors without breaking production
Removing access is urgent if the person left on bad terms, and sensible even if they left on good ones. Do it in this order, because the order decides whether you break your own app.
- Remove personal accounts first. Take the person out of the repository, the cloud console, the database admin tool, the password manager and any team chat. This is low risk: the app does not depend on their personal login.
- List every shared secret before you rotate it. Database passwords, API keys, SSH keys and deploy tokens are often used by the running app. If you change one without updating the app's configuration, production goes down.
- Rotate shared secrets with someone who can redeploy. Change each secret and update the app's configuration in the same step, then check the app still works. If nobody on your side can do this safely yet, leave the shared secrets until your new team's first day, and keep the personal accounts removed.
Hours 24 to 36: prove you can recover
A backup you have never restored is a hope, not a backup.
- Take a fresh database backup now, and store a copy outside the hosting account.
- Restore it somewhere else (a new database on your laptop or a spare server) and check that the data is there. Our guide to backing up and restoring MySQL, PostgreSQL and MongoDB walks through the commands.
- Copy the code with every branch and tag, not just the main branch. Unmerged work often lives on a branch only the developer knew about.
- Save the configuration. Environment variables and settings files hold the values the app needs to run. Store them in a password manager, never in a shared document.
- Snapshot the servers if your hosting allows it, so you can roll back if something goes wrong later.
Hours 36 to 48: write down what you know
The knowledge that walked out of the door is harder to recover than the code. Capture what you can while it is fresh:
- How a change gets from the code to the live site, even if the answer is "the developer ran a script on their laptop".
- Where the logs are, and which scheduled jobs run (nightly emails, reports, data imports).
- Every third-party service from the inventory above, and what it does for the app.
- Known bugs, workarounds your team uses, and anything customers regularly complain about.
- What the developer was working on when they left.
If the developer is still on speaking terms, a one-hour recorded call in which they share their screen and deploy the app is worth more than any document they could write.
What not to touch
The first instinct after a departure is often to fix things. Resist it until someone has read the code.
- Do not deploy changes. If a deploy fails, nobody may know how to roll it back.
- Do not upgrade the framework or dependencies. Even if Django, Python or Node is past its end-of-life date, an upgrade is a planned project, not an emergency task.
- Do not delete servers, buckets or databases that look unused. Some of them are backups, queues or old integrations that something still depends on.
- Do not let a new freelancer push straight to production on day one. Ask them to get the app running from a clean copy first.
- Do not decide to rewrite yet. Most inherited apps are worth keeping. A rewrite decision belongs after an assessment, not in a week of stress.
When to bring in a new team
You need outside help when nobody on your side can deploy the app, when customers are reporting problems nobody can fix, or when a security review or an end-of-life date is coming. A good takeover starts with an assessment, not with code changes: the new team gets the app building and deploying from a clean copy, moves every account into your name, lists the dependencies and their support dates, reviews security, and gives you a written risk list before any monthly work begins.
That is how we run software maintenance and takeovers at MicroPyramid: a fixed-scope Takeover Assessment first, then a month-to-month retainer for fixes, upgrades and new features, with the runbook and access map written down so you are never stranded again.
A checklist you can copy
- Repository owned by our organisation; two of our people are owners
- Hosting, database, domain, DNS, app stores and payments in our company's name
- Departed person's personal access removed everywhere
- Shared secrets listed, and rotated with someone who can redeploy
- Fresh database backup taken and test-restored
- Code copied with all branches and tags
- Configuration saved in a password manager
- Deploy process, scheduled jobs, logs and third-party services written down
- No deploys, upgrades or deletions until a new team has read the code
Frequently Asked Questions
What should I do first when my developer quits?
Confirm that your company owns the code repository, hosting, database, domain and every paid account the app uses, and that at least two of your own people can log in to each. Then remove the departed person's personal access, take a backup and prove it restores. Changing code can wait.
The developer will not hand over the code. What can I do?
Ask in writing, check what your contract says about who owns the code, and take legal advice if needed. In the meantime, look at what you already control: if the hosting account is yours, the running code is on your servers and can be copied from there. This is why the hosting account should always be in your company's name.
Should I change all the passwords immediately?
Remove the person's personal accounts immediately; that is safe. Rotate shared secrets such as database passwords and API keys only together with someone who can update the app's configuration and redeploy, because the running app uses them and changing one on its own can take production down.
Can a new team take over an app with no documentation?
Yes, as long as you can give them access to the code and the hosting. Reading undocumented code and reconstructing how it is built and deployed is a normal part of a takeover assessment, and the documentation written along the way becomes yours.
Should we rewrite the app now that the developer is gone?
Usually not. Most inherited apps are worth keeping, and a rewrite started in a crisis tends to take longer than expected while the old app goes unmaintained. Decide after an assessment shows whether keeping, stabilising, upgrading or rebuilding costs least.
How long does it take for a new team to take over an app?
An assessment that gets the app building and deploying, maps the accounts and lists the risks typically takes one to two weeks. A first month of stabilisation (backups, monitoring, safe deploys and the most urgent fixes) usually follows before regular monthly work.