Your Developer Left: What to Secure in the First 48 Hours, and What Not to Touch

MicroPyramid 7 min read

Your Developer Left: What to Secure in the First 48 Hours, and What Not to Touch

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.

  1. 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.
  2. 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.
  3. 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.

Share this article
Facebook X LinkedIn

Start with a discovery call.

  1. 01 · TODAY Book a free 30-minute call Tell us what you run and where it hurts.
  2. 02 · WITHIN 24 HOURS We reply From the engineers you would work with.
  3. 03 · ON THE CALL Your first step A fixed-scope sprint or audit, not an open-ended retainer.
Book a Free Discovery Call
Email
hello@micropyramid.com
Phone
+91 99591 66266
Offices
Plano --:--Hyderabad --:--Sharjah --:--
You own
All code & IP, from day one

We reply within 24 hours