Quiet Mind Creative
What Happens When Your Developer Disappears
Your web developer stopped answering and the site still works. What to check first, from the domain to the code, and why reading comes before fixing.

The emails have stopped getting answers. Maybe your developer took a full-time job, maybe they’re overwhelmed, maybe you’ll never find out. Meanwhile the site is up and the app still works, so nothing needs fixing yet, but you’ve started to wonder what you’d do if something broke.
The good news is that a website doesn’t stop working because its developer stopped replying. It stops when something expires: a domain, a hosting plan, a card on file. So the first job is finding out what you actually own, and that doesn’t start with the code. After that, the order that works is to get it running, find out what’s fragile, and decide what to leave alone. Fixing comes last, even if there’s something you badly want fixed.
Those four steps are the headings we use when we take over software someone else built, and they work as a checklist whether or not you hire anyone. Our real example is Easy Screenshot Plus, a Firefox extension we picked up after the original open-source project had gone more than three years without a change. It’s our own product rather than client work, but it went through the same four steps.
Where everything lives, and whose name it’s in
Start with a list of everything your site or app depends on: the domain, wherever its DNS is managed (often somewhere else), the hosting, the code repository, email, the Apple or Google developer account if there’s an app, and every outside service it uses for payments, forms, email delivery, maps, or analytics. For each one, you want three answers: whose name it’s in, whose card pays for it, and who can log in.
Your own records know more than you’d expect. Card statements and old invoices show what you’ve been paying for, and searching your inbox for “invoice” or “welcome to” turns up accounts created along the way. If the developer is gone, the next best source is whoever at your company was on the emails with them.
The answer to watch for is an account in the developer’s name, with you holding a shared password. That’s access, and it lasts until they change the password or close the account. Ownership means the account is yours and the developer is a user on it.
The domain deserves the first look, because your website, your email, and every link to you depend on it, and it has a hard expiry date. For .com and other generic domains, ICANN requires registrars to send renewal reminders to the registrant about a month and a week before expiry, and again shortly after (Expired Registration Recovery Policy). If the registrant is your former developer, or the contact email is theirs, those reminders go to someone who isn’t reading them. If nobody renews, the registrar switches off the domain’s DNS before deleting it, and your website and email go down with it.
Code and apps have the same problem in different places. GitHub’s repository transfer moves the history, issues, and pull requests to a new owner and redirects the old links, but someone with admin access has to start it. An iPhone app published from your developer’s Apple Developer account can move to yours with an app transfer, if it meets Apple’s criteria. The app keeps its ratings and reviews, and existing users keep getting updates, but their account holder has to start that too.
Easy Screenshot Plus shows the same split from the other side. The original code was open source, so we could fork it. What a fork can’t take is the original’s users: Easy Screenshot Plus went out as a new add-on, with its own name and ID, and started from zero.
So if you can reach your developer even once, ask for transfers before explanations. Explanations help, but transfers are the part only they can do. If they can’t be reached, each provider’s support team is the next stop, and what they can do for you depends mostly on whose name is on the account.
How to run it
Next: can anyone besides the original developer make a change and get it live? Here’s a simple test: if the phone number on your site needed changing today, who would do it, and how?
For whoever takes over, answering that means a working copy on their own machine and a deploy they’ve done themselves, so the first real change isn’t also the first experiment. This is where the undocumented things tend to turn up: a password nobody wrote down, a build that only worked on one laptop, a step someone did by hand every time.
Our first release of Easy Screenshot Plus made two changes most people would notice. The file manager stopped opening after every save (it’s a setting now), and screenshots got readable names like Screenshot 2026-06-07 at 6.14.17 PM.png. The rest was plumbing: a new add-on ID, a manifest updated to replace a key Firefox had deprecated, and current tools to check the extension against today’s Firefox. Features came in the releases after. When a first release is that small, anything that goes wrong has very few places to hide.
If someone you hire wants to open with a big change, ask what their first deploy will be. It should be boring.
Handle with care
With the project running, the reading starts in earnest: how it’s put together, which parts are solid, and which ones need care. Those last ones are often perfectly well written. They’re the places where a small-sounding request reaches further than it looks.
In Easy Screenshot Plus, the request was about as plain as requests get: let me move a box after I’ve drawn it. The original editor drew every shape straight into the screenshot, so a box stopped being a box the moment you let go of the mouse. It was just pixels. Changing that meant revisiting more than the drawing tools. Undo saved whole copies of the picture, so it had to learn about shapes. Crop had to move the shapes along with the picture, and blur had to leave them alone. Saving had to make sure the selection handles never ended up in the image. There was a shortcut on the table, keeping the pixels and storing a note about each shape alongside them, and we passed on it because after a crop or an undo, the note and the picture would disagree.
None of that is visible from the outside, which is why two developers can quote very differently for the same small request. A “handle with care” list tells you in advance which requests are small and which only sound small: the integration nobody’s touched in years, the deploy step someone does by hand, the one-line feature that turns out to involve undo.
Leave alone
The last heading is the shortest and the easiest to skip: the parts that already work. For Easy Screenshot Plus, that’s the reason we used it in the first place, capturing and annotating a page without leaving the browser. The annotation work changed how the editor stores every shape and kept that quick, in-browser workflow.
A new developer’s first instinct is often to change whatever’s unfamiliar, and unfamiliar code is easy to mistake for bad code. Writing down what stays gives everyone, including the developer, something to check that instinct against. If the first thing you hear about your software is that it needs rebuilding, ask what they read to reach that conclusion. Sometimes a rewrite is the right call, and The Case Against Starting Over gets into when. It should come out of the reading, though, not replace it.
What to do this week
You don’t need to understand the code to make real progress:
- List everything the site or app depends on, and for each item, whose name it’s in, whose card pays for it, and who can log in.
- Find out when the domain expires and which email address gets the reminders.
- If you can reach the developer, ask them to move the domain, hosting, repository, app store listing, and service accounts into your name.
- Run the phone number test.
- Gather whatever documentation exists, even if it’s out of date.
When someone does take it over, expect them to read before they fix, and to leave the notes behind. Then the next handover starts from those four headings, not from a disappearance.
How we can help
A website or app someone else built: understood first, then fixed, improved, and moved forward.
Ongoing support and maintenance
Updates, fixes, platform changes, and steady improvements for websites, web apps, and native apps, long after launch.

