How to Hand a Project Over

A handover is what decides whether the next person spends a day or a month finding out how things work. Most of the work is simple, and it costs little if you do it before anyone has left.

How to Hand a Project Over — Troiana insight cover

In short

A good handover transfers access, code, knowledge and responsibility. Move every account into the client's name, deliver the code with full history, document how to run and deploy it, list known problems, and hold live walkthroughs. Then prove it works: have the receiving team deploy a small change without help. Plan handover from the start of a project, rather than in its final week.

What it needs to achieve

A handover has one test: can someone new run, change and fix this system without calling the person who built it? Documents are only a means to that end. Plan for that test, and everything else becomes clearer.

This applies whether an agency is finishing a project, a freelancer is moving on, an employee is leaving or a team is taking over. For the commercial side, your contract should already say what's included. See what should be in a web contract.

1. Access and accounts

Start here. It's the part most likely to turn into a dispute, and the hardest to fix later. Make a list of every service, and record who owns each one.

CategoryExamplesCheck
Domain and DNSRegistrar, CloudflareIn the client's name; registrar lock on; renewal card is theirs
HostingServer, Vercel, database hostClient is the owner, with billing
CodeGitHub, GitLabRepository owned by the client's organisation
Email and SMSSendGrid, mail hosting, SPF and DKIM recordsDomain verified under the client's account
PaymentsStripe, PayPalClient's legal entity and bank details
Analytics and searchGA4, Search ConsoleClient is an owner
DesignFigma, fonts, stock licencesFiles transferred; licences in the client's name
App storesApple, Google PlayClient's developer accounts

Then remove access for anyone who no longer needs it, and rotate shared credentials and API keys. Shared passwords that were sent over chat should be considered compromised. A password manager with a shared vault makes this much simpler. See how to handle secrets and API keys.

2. Code

  • Full repository with history, not a ZIP of the latest version.
  • All branches that matter, with old ones removed or labelled.
  • No secrets in the code or history.
  • An .env.example that lists every required variable, with descriptions.
  • Tagged releases, including the version now in production.
  • A list of dependencies, plus anything paid or licensed.

If a tool such as Lovable or Replit was used to build it, confirm the code can run outside that platform. See how to export code from Lovable.

3. Documentation that gets read

Don't write a 50-page manual that nobody opens. A short README and a few focused documents are much better. Cover these:

Getting started. How to run the project locally, from a clean machine, step by step. Test it by having somebody follow it.

Architecture on a page. Main components, how they connect, and where data lives. A rough diagram will do.

Deployment. How code gets to production, how to roll back, and who can do it. See how to do a zero-downtime deploy.

Decisions and the reasons for them. Why this database? Why this odd workaround? Short notes prevent the next person from “fixing” something that's there for a reason.

Known problems. Be honest about bugs, technical debt, fragile areas and things you'd do differently. This is the most valuable section, and the one most often left out.

Operations. Backups and how to restore them, monitoring and alerts, scheduled jobs, renewal dates for domains and certificates, and contact details for third-party suppliers.

Content editing guide, if non-technical people will update the site. A short screen recording is often better than written instructions.

AI tools are useful for producing a first draft by reading the code, but a person who knows the history has to correct it. An AI can't tell you why a decision was made unless somebody wrote it down.

4. Data and files

  • Confirm that database backups run, and restore one to prove it. See how to back up a production database.
  • Transfer design source files, not just exports: Figma files, brand assets and fonts.
  • Hand over content and media, including originals.
  • Review what personal data is held, and where, and update any data agreements. See what a DPA is.

5. Knowledge transfer

Documents only go so far. Schedule live time too:

  1. Walkthrough of the system. Record it.
  2. Deploy together. The outgoing person leads while the new person watches.
  3. Reverse it. The new person deploys, with the outgoing person watching.
  4. Fix a real small bug together. This reveals more than any document.
  5. Agree on a support period, such as two to four weeks of paid or included questions after handover.

Overlap time is the best investment you can make. Rushing this step often costs many times more later.

Transferring the skill, not only the documents
WalkthroughRecorded
Deploy togetherThe outgoing person leads
Reverse itThe new person deploys, watched
Fix a small bugReveals what's missing
The final test comes next: someone new deploys a small change alone. If that fails, the handover isn't finished.

6. The final test

Before signing off:

  • A person from the new team sets up the project on their own, from the README.
  • They make and deploy a small change, and roll it back.
  • They restore a backup to a test environment.
  • They can name who to contact for each third-party service.
  • The outgoing team's access has been removed, and the site still works.

If any of those fails, the handover isn't finished.

Plan it from the start

It's far easier to do this along the way. Register accounts in the client's name from the first day, keep the README updated with each change, record decisions as they're made, and keep documentation in the repository next to the code. Include handover in your original estimate. A client should be able to own their code, domain and designs throughout the project, and not just at the end.

If the handover is difficult

If a supplier has gone quiet or won't cooperate, start with what you control: your domain registrar, your payment accounts and your own hosting. Ask for a list of credentials in writing, referring to your contract. Then have a new developer do a short audit and work out what can be recovered. Get legal advice if you're being refused access to things you've paid for.

If you need help taking over or handing over a project, book a call.

Common questions

What should a website handover include?

Ownership of all accounts, the code with its history, documentation on running and deploying it, design source files, backups, a list of known issues, and live walkthroughs. The test is whether a new person can run and change it without help.

How long should a project handover take?

It depends on the system. A simple site could take a few days. A complex product can need several weeks of overlap. Plan time for a new person to deploy changes under supervision, because that's what reveals missing knowledge.

Who owns the code when a project ends?

That depends on your contract and local law. Don't assume that payment transfers ownership. Your agreement should state who owns the code and designs and when ownership transfers, and accounts should be in your organisation's name from the start.

What if my old developer won't hand over the project?

Secure what you control first, such as your domain and payment accounts. Then request access in writing, referring to your contract, and ask a new developer to assess what can be recovered. Take legal advice if you've paid for work and are being refused access.

Have something worth building right?