Skip to content
Lessons #MVP#Startups#Founders#Consulting#Handover

What an MVP Handover Should Include

· 6 min read

Nobody discovers this at handover. They discover it four months later, when the developer has moved on and something needs changing.

The code is in a repository under their account. The server is on their hosting, billed to their card. The domain was registered with their email. The Stripe account was opened in their name, because it was faster. Nothing was stolen and nobody acted in bad faith. It just never got moved, because moving it was never anybody’s job.

You own the product. You do not own the means to run it.

The question that settles it

Could another developer take this over on Monday, without calling the last one?

If the answer is no, the handover is not finished, however good the software is. Everything below is just that question, broken into parts you can check.

Two panels. On the left, the repository, server, domain, payments and third-party services all sit inside the developer's accounts. On the right, the same five sit in the founder's accounts, with the developer holding access that can be revoked. How it usually ends How it should end The developer's accounts Repository Server and database Domain and DNS Payments Third-party services If they disappear, it all disappears with them. Handover Your accounts Repository Server and database Domain and DNS Payments Third-party services The developer holds access you granted, and can revoke.
The difference is not the code. It is whose name is on the account the code runs in.

The five that must be in your name

The repository. Under your organisation, not forked into it at the end. If it only appears the week the project closes, the history is usually gone with it, and the history is how the next person learns why things are the way they are.

The server and the database. Your hosting account, your card. A production database somebody else can delete is not yours in any sense that matters.

The domain and the DNS. Registered to you, with the registrar login in your possession. This is the one that strands people hardest, because a domain nobody can move is a business nobody can move.

Payments. Stripe, PayPal, the payment processor your country uses. This one is not even a preference: these accounts are tied to a legal entity and to a bank account, and running your revenue through someone else’s is a problem long before it is an inconvenience.

Third-party services. The email sender, the file storage, the error tracker, the API keys. Each one is small. All of them together are the system.

The three that are not accounts

A README that assumes nothing. How to run it locally, how to deploy it, what every environment variable is for. The test is simple: hand it to a developer who has never seen the project and watch whether they get it running without asking a question.

The decisions, not just the code. Why this database and not that one. What was deliberately left out. What is held together with tape and should be replaced when there is budget. A good handover includes the honest list of what is weak, and a developer unwilling to write that list is telling you something.

Your data, in a format you can read. An export you can open. Not because you want to leave, but because a product whose data only exists inside one running system is one bad night away from existing nowhere.

Put it in the contract, not in the handover

All of this is easy at the start and awkward at the end. At the start it is a line in a document. At the end it is asking someone to spend unpaid days moving things while they are already working somewhere else.

Three sentences are enough:

The code, the infrastructure and all accounts are in the client’s name from day one. The developer works with access the client grants. On completion, that access is withdrawn and nothing stops working.

If a developer pushes back on that, the reason is worth hearing out loud. There are honest ones: some agencies genuinely do deploy everything to shared infrastructure for operational reasons, and will say so plainly and tell you the cost of doing it your way instead. There are also the other kind, where the lock-in is the retention plan.

Either way you want to know before you start, not after.

The test

When the work is done, do this once:

Take the README, give it to someone who was not involved, and have them get the thing running. Then log in to every account yourself. Then change the password on one of them and check that nothing breaks.

If all three work, you own what you paid for.


This is why I put it in writing first: on my projects the code, the infrastructure and the accounts are the client’s from day one, and the handover includes enough documentation that another developer can pick it up. If you are still choosing who to work with, where to find developers for your startup covers the question that comes before this one.

Related Posts