It usually starts small. The site throws a security warning because a certificate didn't renew. A customer emails to say the booking form is broken. You text the developer who built everything. No reply. A day later you try the hosting login and realize the password reset goes to their email address, not yours.
This is one of the most common and most avoidable crises a small business or startup can face. When people search "developer disappeared" or "who owns my code," they're usually asking three different questions at once, and each one has a different answer:
- Code: Who holds the copyright in the software that was written for you?
- Domain: Who is the registered holder of your domain name, and who controls the registrar account?
- Hosting and accounts: Who controls the servers, the cloud account, the code repository, DNS, email, and the API keys your product depends on?
Legal ownership and practical control are not the same thing. You can legally own a domain and still be locked out of it. You can hold every login and still not own the copyright in the code. This guide walks through each layer, what to do in the first 48 hours, and what to put in your next software ownership contract so this never happens again.
Not legal advice: This article is general information for founders and operators, not legal advice. Copyright, contract, and domain disputes turn on your specific documents and facts. If real money, a client relationship, or a lawsuit is on the line, talk to a licensed attorney in your jurisdiction.

The first 48 hours: triage before you touch anything
When something breaks and the developer is unreachable, the instinct is to start changing settings. Resist it for a few hours. Some changes can lock things up further, especially with domains.
- Gather your paper trail. Contracts, statements of work, proposals, invoices, payment receipts, and email or chat threads where scope and deliverables were discussed. These documents decide most ownership questions.
- Look up your domain's registration record. ICANN's free Registration Data Lookup tool shows which registrar holds your domain and, depending on privacy settings, may show who the registrant is. Note the registrar name and expiration date.
- List every system the business depends on. Registrar, DNS provider, hosting or cloud account, code repository, transactional email, payment processor, analytics, app store accounts, and any third-party APIs. For each, write down who is the account owner and where billing goes.
- Check what you can already reach. Do you have any login? Are you listed as an admin, owner, or billing contact anywhere? Is the company card on file? Each of these is leverage with the provider.
- Save a copy of what's live. If the site or app is still running and you have any access, back up files and databases now, before a billing lapse or expiration takes them offline.
- Try one calm, documented outreach. Email the developer (and any agency they worked for) with a specific list: credentials, repository transfer, domain transfer, and a deadline. Keep it factual. If this ends up in a dispute, that email matters.
Your domain: the registrant is what counts
For domain recovery, the key question is who is listed as the registrant (the registered name holder), not who paid the invoice. If a developer registered your domain under their own name or their own registrar account, you may have a legitimate claim but a practical problem.
Moving a domain to a registrar you control requires an authorization code. ICANN describes the Auth-Code (also called an EPP or transfer code) as a code created by the registrar to identify the domain holder and prevent unauthorized transfers, and it is required to move a domain from one registrar to another.
Timing rules can also trip you up. Under the current Transfer Policy, a registrar may deny a transfer within 60 days of initial registration, and a domain can be subject to a 60-day lock after changes to the registrant's name, organization, or email. ICANN's guidance has long noted that registrars may, but are not required to, let registrants opt out of that lock, and that one way to avoid it is to request the transfer before changing registrant details.
These rules are in motion. In March 2025, ICANN's policy community approved a package of 47 recommended changes to the Transfer Policy, including shorter locks for new registrations and transfers and the removal of the lock tied to registrant data changes. Some registrars have already begun rolling out related updates; one registrar, for example, announced that starting August 4, 2026, the registrant rather than the admin contact becomes the primary party for transfer authorization. Before you act, check your registrar's current help pages for which rules apply today.
Practical moves for domain recovery:
- If you are already the registrant, contact the registrar's support directly, verify your identity, and request access to the account or the auth code.
- If the developer is the registrant, ask them to either push the domain into a registrar account you own or provide the auth code. Get confirmation in writing.
- If they won't respond, contact the registrar with your evidence: invoices showing you paid for the domain, your business records, and the communication history. Registrars handle these requests differently, so ask what documentation they need.
- Watch the expiration date. A domain that lapses during a dispute is a much bigger problem than a slow transfer. If you can renew it, do.
Your code: paying for it doesn't automatically mean owning it
This is where many founders are surprised. Under U.S. copyright law, the person who creates a work is generally its author and initial owner. "Work made for hire" is the main exception, and it is narrower than most people assume.
According to the U.S. Copyright Office's Circular 30 on works made for hire, a work qualifies in one of two ways:
- It was prepared by an employee within the scope of their employment, or
- It was specially ordered or commissioned for one of nine specific uses (such as a contribution to a collective work, part of an audiovisual work, a compilation, or a supplementary work), and the parties signed a written agreement saying it is a work made for hire.
That second path is why "work for hire" language alone may not protect you when you hire a freelancer or an outside agency. Custom software often doesn't fit neatly into those nine categories. As one law firm explains, a company that labels a freelance software contract "work for hire" and assumes it owns the code can be making a common and consequential error unless the contract also includes a valid copyright assignment.
An assignment has its own formality: the Copyright Act says a transfer of copyright ownership is not valid unless it is in writing and signed by the owner (or their authorized agent). A handshake, a paid invoice, or a Slack message saying "it's all yours" may not be enough on its own.
What this means in practice:
- If the developer was a W-2 employee building your product as part of their job, the code is very likely yours.
- If they were a contractor and you have a signed agreement that assigns IP to your company, you are in a strong position.
- If they were a contractor and there's no written assignment, ownership is genuinely unclear. You may still have a license to use what you paid for, but the strength and scope of that license is a question for a lawyer.
- Even with clear ownership, you may still need the developer's cooperation to get the actual source code if it lives only in their accounts. That's the control problem, covered next.
Your repository: make the company the owner, not a person
The cleanest way to avoid a hostage situation is to make sure your source code lives in an account the business controls from day one, with developers invited as members.
On GitHub, create an organization for the company and make yourself (and ideally a second trusted person) an owner. GitHub's documentation states that organization owners have complete administrative access to the organization, and that owners also have admin access to every repository the organization owns. If your code currently sits in a developer's personal account, it can be moved, but transferring a repository requires administrator access to it, which means the developer has to do it or grant you that access.
On GitLab, the equivalent is a group the company owns. GitLab describes the Owner role as full control over the project or group, including deletion and visibility settings, and notes that each group must always have at least one Owner. Moving a project into your group requires the Owner role on the project being transferred, so again, you need cooperation if the project lives in someone else's namespace.
Two owners matters. If the only owner is the person who disappears, you're back where you started.
Hosting and everything else: the quiet single points of failure
Domains and code get the attention, but outages often come from the accounts nobody wrote down. Review each of these and confirm the business is the account holder, with your billing details and at least one company-controlled admin email:
- Cloud or hosting account (root or owner account, not just a sub-user)
- DNS provider, if different from your registrar
- Business email and the domain's mail records
- Transactional email and SMS services
- Payment processor and subscription billing
- App Store and Google Play developer accounts
- Analytics, ad accounts, and tag managers
- Third-party API keys and webhooks, especially anything tied to payments or customer data
- A password manager the company owns, with shared vaults for these credentials
Quick decision guide
| What you find | What it likely means | Next move |
|---|---|---|
| You're the domain registrant but can't log in | You likely have the stronger claim; it's an access problem | Contact the registrar, verify identity, recover the account |
| The developer is the domain registrant | You need their cooperation or the registrar's dispute process | Request a push or auth code in writing; document payments; renew if expiring |
| Signed contract with an IP assignment clause | Strong position on code ownership | Use the contract to request source code and repository transfer |
| Contractor, no written assignment | Copyright ownership is unclear | Talk to a lawyer before rebuilding or threatening action |
| Code is in the developer's personal GitHub or GitLab | Only they (or an admin) can transfer it | Request a transfer to your organization or group; keep any copies you have |
| Hosting billed to the developer's card | The account may be theirs, and it could lapse | Ask the provider about account ownership; back up data immediately |
What to put in your next software ownership contract
The cheapest time to solve this problem is before any code is written. A lawyer should draft or review the actual language, but these are the decisions your contract should settle clearly:
- Intellectual Property Clause: A written assignment of copyright and other IP in the deliverables to your company, not just a "work for hire" label. Spell out when it takes effect (for example, upon creation or upon payment).
- Pre-existing and third-party code: Developers often reuse their own libraries and open-source components. The contract should say what they keep, what license you get to it, and that open-source licenses will be disclosed.
- Access to Accounts: All domains, hosting, repositories, and service accounts are created under the company's name and billing, with the company as owner and the developer as a member or collaborator.
- Credential and documentation handover: A list of what gets delivered (source code, database schemas, deployment steps, environment variables, admin credentials) and when.
- Exit Strategy: What happens at project completion or termination: a transition period, removal of the developer's access, and confirmation in writing that everything has been handed over.
- Response expectations: How quickly the developer must respond to critical issues, and what happens if they can't continue the engagement.
Protecting your interests going forward
Good relationships with developers matter, and most developers are not trying to hold anyone hostage. They get sick, change careers, take full-time jobs, or simply drift. Your setup should survive that without anyone needing to behave badly or heroically.
- Consult with a legal professional to draft or review development contracts before work starts.
- Keep regular, automated backups of code and data in storage the company controls.
- Keep at least two company owners on every critical account.
- Run a quick access review whenever a developer joins or leaves, and at least once a year.
- Maintain a good working relationship with your developer and ask for documentation as you go, not at the end.
The bottom line
When a developer disappears, the damage depends almost entirely on decisions made months earlier: whose name is on the domain, whose account holds the repository, and whether anyone signed an IP assignment. If you're in the middle of it now, gather your documents, check your domain's registration record, protect anything that might expire, and get legal advice on the code. If you're not, spend an afternoon this week moving every critical account under the company's name. It is far less painful than doing it during an outage.
Tech Lab Miami is a South Florida community for founders, operators, and technology teams focused on practical AI, automation, and software. Questions like this one, about who actually controls the systems a business runs on, are exactly the kind of operational detail worth getting right early.
FAQs
What happens if I don't own the code?
If the developer holds the copyright and there's no written assignment, they may have the right to control how the code is used, copied, or modified. You may still have an implied license to use what you paid for, but its scope can be uncertain. That can affect your ability to hire someone else to maintain it, sell the business, or raise money. A lawyer can review your documents and tell you where you stand.
My developer disappeared. Can I just hire someone new to keep working on the code?
Often you can keep running and maintaining what you have, but whether you can freely modify and build on it depends on ownership or license terms. If ownership is unclear, get legal advice before a major rebuild, and make sure the new engagement includes a clear IP assignment from the start.
How can I ensure I own my domain?
Register the domain in your company's name, in a registrar account the company controls, with a company email address you'll keep long term. Turn on auto-renew, keep billing current, and confirm the registrant details using ICANN's lookup tool. If a developer registered it for you, ask them to transfer it into your account now, while the relationship is good.
Is a "work for hire" clause enough to own custom software?
Not always. For contractors, a commissioned work only qualifies as work made for hire if it falls into one of the specific categories listed in the Copyright Office's Circular 30 and there's a signed written agreement. Many software contracts include both work-for-hire language and a backup copyright assignment for that reason.
Is it necessary to have a lawyer review my contracts?
For any engagement where the software is central to your business, yes, it's worth it. A lawyer can make sure the IP assignment is valid, that pre-existing and open-source code is handled, and that the exit terms actually work. The cost of a review is usually small compared to the cost of a dispute over code you thought you owned.
