Define handover as a transition, not a compressed folder
When a web project ends, seeing the site online does not prove that the company can administer, maintain or move it. The handover should connect the visible result with the accounts, files and procedures that support it. The aim is for the client and provider to identify what exists, who is responsible for each part and what would happen if somebody else had to continue the work.
Agree this outcome before development begins. A proposal can state which assets will be delivered, which services will remain managed by the provider and which support sits outside the initial price. The final conversation then does not depend on assumptions. The exact list varies by technology, but the essential categories — ownership, code, content, configuration, access and operation — can be defined within the scope.
Prepare an inventory of accounts and owners
The company should know the owner account for the domain, DNS provider, hosting, code repository, database, transactional email and every external service used by the website. MDN distinguishes the domain, which is the address through which people find the site, from the hosting that serves its files. That separation matters: paying for one does not automatically provide control of the other.
For each service, record the owner, administration address, billing method, people with access and recovery procedure. There is no need to copy passwords into the inventory. The useful information is where they are held and who can reset them. If an account belongs temporarily to the provider, the handover should explain whether it will be transferred, replaced or remain managed under a maintenance agreement.
- Domain and renewal date.
- DNS provider and location of the records.
- Hosting, deployment and database.
- Repository, forms, email and third-party services.
- Owner, administrators and recovery route for every account.
Deliver files in a structure another person can understand
The technical package should not be limited to a copy of the production website. Include the relevant source code, build instructions, configuration without secrets, database migrations and assets required to generate the published result. MDN explains that a website brings together code, styles, media and other connected files; preserving their structure and paths is part of keeping the project usable.
Separate working resources from final files. Editable originals for logos, icons or images may be needed for later changes, while optimised versions are what the website uses. Also state which items belong to the client, which use a third-party licence and which cannot be redistributed. A short asset inventory prevents technical access being confused with usage rights.
Transfer access without turning documentation into a secret store
Do not send every password, API key and credential inside the handover document. OWASP treats secrets as items with a lifecycle covering creation, rotation, revocation and expiry, and recommends appropriate access controls. In practice, documentation can identify a credential and its purpose while the value is shared through the agreed manager or secure channel.
Create individual identities where the service supports them and grant only the permissions required. Cloudflare's account role documentation demonstrates how a platform can separate capabilities instead of sharing one account with full control. Once the handover is accepted, remove temporary invitations and rotate keys created solely for development when that can be done without disrupting the website. Record who will check this and when.
Document publication, recovery and a future provider change
A useful handover explains how a validated change reaches production. Describe the authorised branch or source, checks performed before release, deployment mechanism and way to return to an earlier version. If backups exist, state what they include, how frequently they are made, where they are kept and how restoration is verified. Saying that there is a backup without knowing the procedure leaves an untested dependency.
Add a minimum portability map: how to export content and data, which DNS records matter and which services would need to be recreated elsewhere. Cloudflare's documentation, for example, supports importing and exporting DNS records, but an export does not replace an explanation of each record's purpose. The aim is not to plan an immediate migration; it is to prevent the architecture existing only in its creator's memory.
Separate the initial handover from ongoing maintenance
Project closure should state what is working at that point and which tasks will require attention later. Dependency updates, domain renewal, form checks, backups and incident response do not happen automatically because the client received the code. Assign an owner or state clearly that the company must arrange one. This distinction prevents a delivery warranty being interpreted as indefinite maintenance.
Include the applicable contact channels and response arrangements when support exists, together with the process for requesting changes that are not incidents. Record recurring costs and the account paying them, without promising that prices will remain unchanged. The client should be able to distinguish services needed to keep the website running from optional tools for analytics, automation or marketing.
Finish with a reproducible acceptance exercise
A handover meeting should involve more than walking through screens. Use a script: sign in with a client-owned account, locate the repository, identify the current deployment, make an allowed edit in a safe environment and find the recovery procedure. There is no need to perform a destructive restoration in production; it can be demonstrated in a separate environment or through recent, verifiable evidence.
Save the final inventory with a date and confirm the exceptions: outstanding items, access retained by the provider and tasks that begin under maintenance. If another person can follow the document and explain the journey without receiving credentials through an unsafe channel, the handover is more robust. This check cannot guarantee that an incident will never occur, but it makes continuity something that can be assessed before the project closes.
- Does the company control or know the owner of every essential account?
- Can the delivered code and assets reproduce the site?
- Are secrets shared and rotated through a defined procedure?
- Can the deployed version be identified and an earlier one recovered?
- Are delivery, warranty and maintenance obligations separated?
Sources and documentation
- MDN: Publishing your website ↗
- MDN: Dealing with files ↗
- OWASP: Secrets Management Cheat Sheet ↗
- Cloudflare: Account roles ↗
- Cloudflare: Import and export DNS records ↗
Content created with AI assistance. Check the sources, date and scope of each guide.