November 15, 2026

Your App Developer Disappeared? What to Do in the First 7 Days

The app works, customers use it, but the person who built it no longer answers. Maybe they changed careers, maybe their company closed, maybe they simply vanished. Meanwhile Apple asks for an update, a customer reports a bug, or the server bill is due and you don’t know where it is paid from.

This happens more often than it seems, and the good news is that it can usually be fixed. What matters is finding out quickly what you control and what you don’t, before a small issue turns into an outage.

Days 1 and 2: find out what you actually control

Before looking for a new developer, take inventory. For each item below, write down where it lives, whose name it is in and whether you have access.

  • Source code: is there a repository (GitHub, GitLab, Bitbucket)? Are you the owner or just a collaborator? If the only copy is on the former developer’s laptop, that is priority number one.
  • Apple Developer account: is the app published from your company’s account or from the developer’s? Who holds the Account Holder role?
  • Google Play Console: same question. Is the developer account yours or theirs?
  • Server and database: where does the backend run (AWS, Google Cloud, Firebase, a VPS)? Who pays the bill? Are there backups, and where?
  • Domain and DNS: whose name is the domain registered in, and when does it expire? If it lapses, the website, the API and email all stop.
  • Paid services: payment processor, email service, push notifications, maps, AI APIs. Each has an account, an access key and a card it is billed to.

You should end up with a simple three-column list: what is yours, what is the developer’s, and what you don’t know. The third column tells you where to start.

Days 2 and 3: recover what is missing

If the app is published from the developer’s account, you don’t have to rebuild it from scratch. Both Apple and Google let you move an app to another developer account while keeping its users and reviews. Apple explains the process in its app transfer guide, and Google in the Play Console documentation. In both cases the transfer has to be started from the account the app is in now, so you need the former developer’s cooperation. The transfer only moves the store listing, not the code: that has to be handed over separately. If the app uses push notifications, Sign in with Apple, subscriptions or in-app purchases, the transfer involves extra technical steps that are best done with a developer.

If they don’t respond at all, get out the contract. Check what it says about code ownership, handing over accounts and what happens when the collaboration ends. If there is no contract or the wording is unclear, talk to a lawyer before taking further steps. The more the business depends on the app, the sooner.

In the meantime, make sure nothing stops for trivial reasons: renew the domain and server if you can, change passwords on the accounts you do have, and check which billing details are in use.

Days 3 to 5: the technical assessment

Once you have the code and server access, a new developer can tell you what state the app is in. A proper assessment answers a few concrete questions:

  1. Does it build? Can the app be built from the code on a fresh machine, without the original author’s help?
  2. How old are the dependencies? Libraries left untouched for years can block a store update or hide security issues.
  3. Does it meet current store requirements? The stores raise their minimum requirements regularly. For example, since August 31, 2026, Google Play only accepts new apps and updates that target Android 16, and older apps that have fallen behind stop showing up for new users on recent phones. An app that hasn’t been touched in a long time may need a few days of work before you can ship even a small fix.
  4. Where are the keys and passwords? Access keys written into the code or shared over chat need to be rotated.
  5. Is there documentation or tests? Neither is mandatory, but their absence makes every change take longer.

The outcome should be a written report, not an impression: what works, what is urgent, what can wait and roughly what each part would cost.

Fix or rewrite?

Many developers’ first instinct when they see someone else’s code is to propose a rewrite. Sometimes that is right, but usually it isn’t. A rewrite is expensive, takes time and reintroduces problems the old version had already solved.

Signs it is worth fixing

  • The app builds and its main features work.
  • The technology is still maintained (for example Flutter, React Native, Swift or Kotlin at reasonable versions).
  • The problems are contained: a few screens, one integration, one service.

Signs a rewrite is genuinely on the table

  • The code no longer builds, and bringing it up to date would cost almost as much as a new version.
  • The technology is no longer maintained and can no longer be published to the stores.
  • The product has changed so much that half the app is no longer used.

Even then, a rewrite can be done in stages: keep the backend and data and rebuild the mobile app, or the other way around. You rarely need to throw everything away at once.

Days 6 and 7: decide who looks after the app from now on

After the assessment, you need a plan for the coming months: who applies updates, who responds when something breaks, how quickly, and how new features are estimated. I wrote about this in more detail in the article on app maintenance after launch.

For apps that have been taken over, the first weeks are usually the busiest: dependency updates, new store requirements, rotated keys, the documentation that was missing. A monthly subscription fits this period well, because you can change priorities from one week to the next without negotiating a new quote for every issue.

How to avoid this next time

Whoever you work with, including me, a few simple rules protect you:

  • The Apple Developer account, the Google Play account, the domain and the cloud account are in your company’s name. The developer gets access, not ownership.
  • The code lives in a repository you own, updated continuously, not just at the end.
  • The contract states clearly that once paid for, the code and accounts belong to you.
  • There is a short document listing every service used, where it runs and who pays for it.
  • At least one other person in your company has admin access to everything that matters.

On the custom projects I build, the source code belongs to the client once paid for, and the details are set out in the proposal before work starts.

Have an app with no developer?

If you are in this situation now, write to me with what you have: what technology the app is built with, which accounts you can access and what worries you most. I’ll tell you what the next steps would be and whether a maintenance and development subscription is a good fit.

Tell me about your idea