Every Nigerian business community has this story, told with the same weary shrug:
"He built our system two years ago. Last month it stopped sending receipts. His number doesn't connect. The new developer looked at it and said he'd have to start from scratch, he can't even get into the server."
Sometimes the developer japa'd. Sometimes he's fine and simply done with old clients. Occasionally he's holding the login hostage for a "retrieval fee." The variations don't matter, because the underlying disaster is identical in every version: the business paid for software and received a service, one that silently expired the day one man stopped answering his phone.
Here's how to make sure that story is never told about you. And if it's already being told, what's actually recoverable.
The autopsy: what "disappeared" actually took
The developer leaving isn't the disaster. Developers legitimately move on, new jobs, new countries, new lives; that's not betrayal, it's employment. The disaster is what left with him, because it was only ever stored in his head and his accounts:
The keys. Hosting account, domain registrar, database credentials, the deployment setup, all registered under his email, paid through his card, recoverable through his phone number. The business owns none of its own doors.
The source code. The actual program, the thing you think you bought, sitting in his private repository or, worse, only on his laptop. What's running on the server is the baked cake; without the recipe, the new developer can taste it but can't change it.
The map. No documentation: what connects to what, why that weird workaround exists, which service renews when. Even with code in hand, an undocumented system costs a newcomer weeks of archaeology, billed weeks.
Notice the pattern: nothing here is about coding skill. It's all custody. And custody is decided at the start of a project, in about an hour of boring setup, or at the end, at archaeology rates.
The ownership kit: what must be in YOUR hands from day one
This is the checklist. It costs nothing but insistence:
1. Every account in the business's name. Hosting, domain, database, email services, payment gateways, created with a company email you control, paid from your card, with your phone on the 2FA. The developer gets invited in as a team member, able to work, unable to lock you out, removable in one click when the relationship ends. Every serious platform supports exactly this arrangement.
2. The code in a repository the business owns. Insist the code lives in version control, GitHub is the standard, under an organization account belonging to the business, with the developer as a member. GitHub's documentation on organization accounts walks through the setup in an afternoon. This one structure converts the disappearance scenario from "start from scratch" to "add new developer, continue Tuesday."
3. A written map, updated as it changes. One living document: every service used, what it does, where it's paid from, when it renews, plus the system's shape in plain language. Ask for it as a deliverable, in the contract, alongside the code, because that's what it is.
4. The contract sentence that decides everything: "All source code, credentials, and project materials are the property of [business], transferred in full on payment." Without it, code ownership defaults into a legal fog where the developer often retains rights you assumed you'd bought. One sentence. Before work starts. (It's also item one of the questions to ask before hiring, the honest builders agree instantly; the pause is the answer.)
5. Proof, not promises. Don't accept "you own everything, don't worry." Log into the hosting yourself. Open the repository yourself. Find the document in your drive. Ownership you can't demonstrate on your own screen is a rumor.
If you're reading this too late
Already ghosted? Triage in this order:
- Secure what still answers to you. Domain first, if it's in your name, your address survives anything. Then any account where your email or card appears; change passwords, add your 2FA.
- Recover access through platforms, not the person. Hosts and registrars have business-recovery processes for exactly this, proof of payment, incorporation documents, and patience often reopen doors the developer's silence closed.
- Extract before you rebuild. Even without source code, a competent developer can usually export the data, customers, orders, content, from a running system. The code may be lost; the business's memory doesn't have to be.
- Rebuild with the kit above, from hour one. The rebuild will sting. Rebuilding ownable means it stings once.
The relationship reframe
None of this is about distrusting developers, the good ones prefer clients with proper custody, because clean handovers protect their reputation too. It's about respecting what software actually is: not a purchase that ends, but a living asset that will outlast any single relationship, including, eventually, the one with us. That's also why the disappearance question and the maintenance question are the same question wearing different clothes, a system nobody can access is just the acute version of why software needs ongoing care.
Build every project as if the handover is guaranteed. Because it is, the only variables are when, and whether it's a formality or a crisis.