When the person who built your software leaves, the first job is access. Make sure your company owns the code repository, the hosting, the database, the domain and every paid tool the system uses, with an admin login held by someone who still works for you. The second job is a written record of what exists and how it connects. Only then is it worth deciding who looks after it next. Most of this can be done in a week if the developer is still reachable, and in two to three weeks if they are not.
This post is for owners and operations leads whose freelancer, agency or in-house developer has moved on, or is about to. It covers the order to do things in, the accounts to check, what documentation to ask for, and a checklist you can use for the handover itself.
The short answer
List every service the system touches and confirm your company is the owner on each one, with billing on a company card. Ask the developer for the repository, environment variables, deployment steps and a list of scheduled jobs before their last day. Change any shared passwords and rotate API keys they held. Then get someone to read the system end to end and write down how it works, so the next person does not start from guesswork.
Start with what you own
The most common problem we see after a developer leaves has nothing to do with code. The GitHub repository sits in their personal account, the hosting bill goes to their card, or the domain was registered in their name because it was quicker at the time. While they are friendly and reachable, this is a short email. Six months later, when a card expires and the site goes offline, it is much harder.
Make a list of every service the system depends on. For a typical internal tool or small web app, that usually includes:
- The code repository (GitHub, GitLab or Bitbucket)
- Hosting (Vercel, Netlify, Render, a cloud account or a VPS)
- The database (Supabase, Firebase, a managed Postgres)
- The domain registrar and DNS provider
- Email sending (Resend, SendGrid, Postmark)
- Payments (Stripe or similar)
- Automation tools (Zapier, Make, n8n)
- No-code or AI builders (Airtable, Retool, Lovable, Bolt, Cursor)
- Any AI model provider whose key the app uses
For each one, write down who the owner is, whose card pays for it, and who has admin access. Your aim is a company account as owner on every line, with at least two people from your company able to sign in as admins.
Moving accounts into your company’s name
Where an account sits in the developer’s name, the cleanest fix is to move the asset across rather than share their login. Most platforms have a proper route for this.
On GitHub, an admin of a repository can transfer it to another account or organisation. GitHub’s documentation says issues, pull requests, the wiki and history move with it, and links to the old address redirect to the new one. If the new owner is a personal account, the invitation expires after a day, so agree a time with the developer and accept it straight away. Create a company organisation on GitHub first, and transfer into that.
For hosting and databases, the usual pattern is to invite your company account to the developer’s team or project, give it owner rights, and then remove the developer. Vercel, Supabase and most similar services support project transfer between teams. Check billing after the move, because some plans reset or need a new card.
For the domain, ask the developer to move it into a registrar account in your company’s name, or to give you the transfer code so you can move it yourself. Domains are the one item where a mistake can take your email and website down together, so do it on a quiet day and check DNS records before and after.
For automation tools and no-code platforms, ownership often sits with the workspace or account, so the simplest route is to make your company account the workspace owner. Zapier, Make, Airtable and Retool all have team or organisation settings for this.
Rotate what they knew
Once your company owns each account, change the passwords the developer used and rotate the API keys they could see. This is housekeeping, and it is no comment on the person. Keys for payments, email and AI providers are the ones that cost money if they leak, so do those first. Every key you rotate needs updating wherever the app reads it, usually in the hosting platform’s environment variables, so make the change, redeploy and test the feature that uses it.
If the app was built with an AI tool, also check whether any key ended up in the code or the browser bundle. We cover how to find and fix that in Exposed API keys in AI-built apps.
The documentation worth asking for
You do not need a long manual. You need enough for a competent stranger to run, change and recover the system. Ask the developer for these before their last day:
- How to run it locally. The commands to install, start and test the app, and the environment variables it expects (names only, values handed over separately and securely).
- How it is deployed. Which branch goes live, whether deploys are automatic, and how to roll back a bad release.
- What runs on a schedule. Cron jobs, scheduled Zaps or Make scenarios, nightly syncs, and what each one does.
- What talks to what. A short list or sketch of each outside service, the webhook addresses, and which direction data flows.
- Where backups are and how to restore one. A backup nobody has restored is a guess.
- Known problems. The bugs they know about, the workarounds staff use, and anything they meant to fix.
Twenty minutes of the developer talking through the system on a recorded screen share often captures more than a document. Ask for one even if they have written notes.
If the developer cannot be reached
Sometimes the developer has disappeared, or the relationship ended badly. You can still recover most systems, but you work from the system itself.
Start with billing. Whoever pays for a service can usually prove ownership to the platform’s support team, so find the invoices. If the domain is in someone else’s name, your registrar’s support and your company documents are the route. For the code, check whether the hosting platform is connected to a repository you can see, and whether a copy exists anywhere in the company.
Then read the live system. Workflow histories in Zapier and Make, deployment logs, the database schema and the code tell you most of what was built. Where the reason for a choice is unclear, ask the people who use the tool every day. They usually know which steps matter and which were workarounds.
A handover checklist
Use this as the agenda for the handover call, and tick each line off in writing.
- Company is the owner on every account in the list above
- Billing on a company card for every paid service
- At least two company admins on each account
- Developer’s access removed or reduced after the handover date
- Shared passwords changed and API keys rotated
- Repository in a company organisation, with the latest code pushed
- Local setup steps and environment variable names written down
- Deployment and rollback steps written down
- Scheduled jobs and automations listed with their purpose
- A recent backup restored to a test environment
- Known bugs and workarounds listed
- Recorded walkthrough of the system saved somewhere the company owns
Deciding who looks after it next
Once access and documentation are in place, you have three choices. You can hire another developer, train someone internal, or hand it to a team that maintains software for a monthly fee. The right answer depends on how much the business relies on the system and how often it changes. We compare those routes in AI automation agency vs freelancer vs in-house.
If you choose outside help, look for someone who starts with a review of what exists before quoting. Our software maintenance service works that way. Custom code and AI-built apps go through the vibe-coded app audit, and automations and no-code tools go through the Automation Audit. Both start at $500. You then invite us as a team member on each platform, so the accounts stay in your company’s name, and a named engineer handles monitoring, fixes and updates from there.
If an automation is already failing, start with fixing the broken automation and do the handover work once it is running again. For setups built on Zapier, Make or n8n, our post on who maintains them after launch covers what to check each month, and Software maintenance cost covers what to budget.
Questions we get asked
The developer says the code is theirs. Is it?
It depends on your contract. Many freelance and agency contracts assign the code to the client on payment, and some do not. Read the agreement, and ask a lawyer if it is unclear. Whatever the answer, get the accounts into your name now so the question does not hold the system hostage.
Should I give the new developer the old developer’s login?
No. Give each person their own account with the access they need. Shared logins make it impossible to tell who changed what, and you cannot remove one person without locking out the other.
How long does a handover take?
With a cooperative developer and a small system, about a week. Without them, or with a system spread across many tools, plan for two to three weeks.
Can you look after software someone else built?
Yes. Most of what we maintain started that way. We review it first, then quote a care plan based on what we found.
Sources and further reading
- Transferring a repository, GitHub Docs, checked 22 November 2026: what moves with a repository, redirects, admin rights, one-day invitation expiry
- Software maintenance and support, the SBD service this post describes















