Picture a small manufacturer whose product page needs two lines changed: a spec update, nothing dramatic. The previous agency handed over a zip eighteen months ago called final-website-v3.zip, and it sits on a Google Drive shared with a marketing head who has since left. The agency has shut down. The owner believes they own the website because the zip is on their laptop, but they don't know which server it runs on. Then it turns out the DNS sits inside an account belonging to the agency's owner, whose personal Gmail is the only recovery address. The zip is useless, and not because the code is bad. The code is the least valuable thing in the handover.
It's a common way for a client to technically "own" everything and operationally control nothing. The zip is a decoy. The real handover lives across six different places, and if any one of them is missing, the client is locked in.
What Clients Think They Are Getting vs What Arrives in the Zip
When a client signs an SOW that says "source code will be handed over at project completion", they imagine — reasonably — that they will receive a working copy of their website that someone else can pick up and continue. What they usually receive is a directory dump. wp-content, a SQL file from a month before launch, a README that says "install on PHP 8.1" and nothing else. No .env template. No list of which plugins are licensed and which are nulled (yes, cracked premium plugins do turn up on client sites, and that's a separate disaster). No note about the cron job that rebuilds the product cache every six hours. No mention of the Cloudflare account in front of the origin.
The zip is necessary, but it is a small part of what a handover actually contains. The rest is operational: who can log into what, whose name is on the bill, whose email gets the renewal notice, and what to do at 11pm on a Saturday when the checkout breaks.
The Six Asset Classes a Real Handover Transfers
Handover items fall into six buckets. Six isn't a magic number (it's closer to seven if you separate analytics out), but these six are where missing transfers cause the most pain.
Code. Not a zip. A Git repository — usually GitHub or Bitbucket — where ownership of the organization has been transferred to the client's account, not "we added your email as a collaborator". There is a difference, and it matters the day the agency leaves the project. Along with the repo: a .env.example with every variable documented (what it is, where to get a fresh value, what breaks if it's wrong), a database export with the exact mysql or pg_restore command needed to bring it back, and a written list of every cron job — both server-level and WP-Cron — with its schedule and its purpose. A nightly cron that regenerates sitemap files, for example, will quietly undo a new team's work in Git if nobody knows it exists.
Credentials are the next one, and the rule to hold to is hosting account ownership rather than sub-user access. (Where hosting is bundled in the price, as with our own Hypersite, ask how you'd move the site out and get that in writing.) If the site runs on Cloudways (Vultr 2 GB is the typical small-business pick), the Cloudways account itself should be in the client's name, with the billing card being the client's card, and the agency added as a team member with deploy rights. Same with Hostinger or DigitalOcean: an account in the client's name, not the agency's reseller account. The billing email and the technical email should be different addresses inside the client's domain, so that when the marketing manager leaves, the renewal notice doesn't bounce.
DNS comes after that, and it is the one that catches almost everyone. The registrar logins. The nameserver records. If Cloudflare sits in front, the Cloudflare account ownership. We will come back to this in the next section, because it is where that story actually breaks.
Licenses are the fourth bucket — ThemeForest single-site licenses, Elementor Pro activations, WPRocket, Gravity Forms, the lot. These are the quiet traps and they deserve their own section too.
Content is the fifth. Original logo files in vector. The brand color values (hex, not screenshots). Product photography in the highest resolution the photographer delivered, not the compressed WebP versions sitting on the server. Copy decks. Anything the client paid a writer or designer to produce, in editable form. A brand book that exists only as a PDF, because the agency never shared the InDesign files, is work the client paid for and doesn't have.
Runbook. A one-page document — we will describe ours at the end — that tells whoever inherits the site how to deploy, how to roll back, where the backups live, who to call, and when to update plugins. Without this the other five buckets are inert. Code without a runbook isn't useless exactly — it just sits there until someone with the time and the stubbornness reverse-engineers what the previous team already knew.
Where Licenses and DNS Quietly Trap You
Two places where the lock-in is almost always accidental, and where the client tends to find out about it eighteen months in, usually on a day when something else is already on fire.
Licenses first. A ThemeForest regular license is single-use and tied to the Envato account that purchased it. If your agency bought the Avada or Astra Pro license on their Envato account and installed it on your site, you do not own that license. You are using it. When the renewal comes around — typically a year later for support and updates — the renewal notice goes to the agency, the renewal payment goes off the agency's card, and if the relationship has ended, the license simply lapses. The theme keeps working but security patches stop. Same story with Elementor Pro, which has activation limits per license tier (we think it's something like 1, 3, 25, or unlimited depending on the plan — Elementor has reshuffled their tiers more than once, so check the current page before you assume anything). If the agency activated your site against their multi-site license, your site occupies one of their slots, and when they deactivate it — for whatever reason — Elementor Pro features stop working on your live site. A checkout form can vanish overnight because of exactly this.
The honest answer is that every premium plugin and theme license should be purchased on an Envato or vendor account owned by the client, billed to the client's card, with the agency added as a technical contact. Slightly more friction at project start, and it saves what is usually a small disaster eighteen months in — or a large one, depending on how central the plugin is to the checkout.
DNS is the other quiet trap. The domain itself may be registered in the owner's name, which is fine. But somewhere along the way the agency moved the nameservers to Cloudflare for caching, and the Cloudflare account belongs to the agency owner's personal Gmail. Now nobody can update an A record to point at a new server. The fix is a registrar-level nameserver change back to the registrar's default DNS. It works, but it costs a TTL window, and some users will still hit the old IP for a few hours because of ISP-level caching. Days of work, for a code change that takes minutes.
The same trap exists with Stripe, PayPal and Square accounts. If the merchant account was opened in the agency's name "to get the integration done faster", the payouts go to the agency's bank account and the tax paperwork sits under the agency's details. Your payment account should be in your own registered business name from day one, with the agency added as a technical user. Non-negotiable.
While we are on accounts that should never sit with us: Google. GA4 property ownership, not just "Admin" access — there is a meaningful difference between being a primary owner and being granted edit rights, and the difference becomes apparent the day the primary owner's Gmail gets suspended. Search Console verification should be done via DNS TXT record so it survives a hosting change, not via an HTML file in the document root that gets nuked the first time someone redeploys. Google Business Profile (the artist formerly known as GMB) ownership transferred to the client's Google account, with the agency as a manager.
The One-Page Runbook Every Handover Needs
A good handover ends with a single document. One printed page, though nobody prints it. Markdown in the repo, a PDF on the client's shared drive, a link in the project closeout email. It contains, more or less:
- The deploy command. Literal.
git push production mainornpm run deployor whatever the project uses, with the expected output and the rough time it takes. - The rollback command. Equally literal. How to revert the last deploy if something breaks within ten minutes of pushing.
- Backup location and frequency, such as nightly database backups to separate storage, kept for 30 days. The runbook says exactly where they are and how to restore one.
- Plugin and core update cadence. A sensible default: security patches within 48 hours, minor updates monthly on a staging environment first, major version updates quarterly with a proper QA pass. The runbook records this for the next team.
- Emergency contacts: hosting support, payment provider support, the domain registrar and, if applicable, the SSL provider.
- Known quirks. Every site has them. "The product import script times out on batches over 400 SKUs, run it in two passes." "Cloudflare's Rocket Loader breaks the Gravity Form on the contact page, leave it disabled for that page rule." Two or three lines, but the kind of thing that takes the next developer half a day to rediscover.
That's the runbook. Not elegant, not comprehensive, but it's what the next team most wishes it had been handed.
One more thing, which belongs in the SOW rather than the handover itself. Before you sign with any agency, ask a lawyer to look at the source code ownership clause. It should read something close to: "All source code, design files, content, and associated digital assets produced under this agreement are the property of the Client. The Agency shall transfer, at project completion, ownership of the project Git repository, all hosting and registrar accounts, all third-party licenses purchased on the Client's behalf, and shall provide a written operations runbook. The Agency retains no license to redistribute or reuse Client-specific code or assets." That last sentence matters. Without it, agencies sometimes claim a perpetual license to reuse "framework" code that turns out to be 80% of your build.
The handover is only ever as clean as the project was, and no project is perfectly clean. If you want a useful test before you sign anything: ask the agency for a redacted sample handover packet from a previous client — the runbook, the credential checklist, the license list. If they have to invent one to send you, you already know what kind of handover yours is going to be.