Fixes & Rescues
My App Developer Disappeared: A Founder's Recovery Checklist
Your developer stopped replying and your app is half-finished. Here's exactly what to secure in the first 24 hours, what you legally own, and how to get the project moving again.
It starts with slower replies, then excuses, then silence. If your app developer has disappeared — mid-project, pre-launch, or right after your last payment — you're in one of the most common situations in startup software, and it's more recoverable than it feels right now. Here's the exact sequence we walk founders through when they bring us abandoned projects.
First: stop paying, start documenting
Before anything else, pause any upcoming payments or subscriptions tied to the engagement, and screenshot your entire communication history — chats, emails, invoices, the original agreement or job post. If this ends in a marketplace dispute or a legal letter, the record you capture today is your evidence.
Don't send an angry message yet. Developers resurface more often than you'd expect — illness, family emergencies, and overcommitment are more common than theft — and the message you send now determines whether the handover, if it comes, is cooperative or hostile.
The first 24 hours: secure every account you can reach
Whatever access you have, use it now to make sure you can't lose more. In order of urgency:
• Google Play Console and Apple App Store Connect — confirm you're the account owner; if the accounts are yours, remove the developer's user access; if the accounts are theirs, this becomes your top recovery priority
• Firebase / Supabase / cloud console — your user data lives here; check who owns the project and add your own email as owner if you can
• Domain, hosting, and email accounts connected to the app
• The code repository (GitHub/GitLab/Bitbucket) — check whether you have access at all, and download a full copy today
• Any API keys and paid services registered under the project (payment providers, maps, SMS, AI APIs) — you're likely still being billed for them
The asset inventory: what a complete handover contains
Recovery means collecting specific artifacts, not 'the app'. Work through this list and mark what you have, what the developer has, and what may not exist at all:
• Source code — the current version, not a months-old zip
• Android signing keystore file and its passwords (see the warning below)
• Store accounts, listings, and the developer accounts that own them
• Backend project ownership (Firebase/Supabase/server), database, and storage
• Environment secrets: .env files, API keys, service-account credentials
• Design files (Figma), documentation, and any admin-panel credentials
The keystore warning every Android founder learns too late
Android apps are updated only with the same signing key that published them. If your app predates Play App Signing and the developer holds the only copy of the keystore file, losing them can mean losing the ability to update the app at all — the recovery path is painful and involves publishing under a new listing.
Check now: Play Console → Setup → App signing. If it says Google manages your app signing key, breathe out — Google holds the key and a new developer can generate a new upload key. If not, getting that keystore file from your old developer just became your single most important recovery item.
If they're unresponsive: escalation that actually works
Send one professional, non-accusatory message with a specific deadline: what you need (the inventory above), by when (5–7 business days is fair), and what happens otherwise (dispute, replacement, review). Specific and calm outperforms angry and vague — you're making cooperation the easy path.
If you hired through Upwork or Fiverr, use the platform: both have dispute processes, held funds can sometimes be recovered, and account-standing pressure is real leverage for an active freelancer. For direct contracts, a short formal letter — even without a lawyer — referencing the IP and deliverables clauses moves many stalled handovers. Full legal action across borders is rarely worth it below five-figure amounts; treat it as leverage, not a plan.
What if you never get the code?
It's a setback, not the end. What matters most is usually recoverable from other directions: if you own the Firebase or Supabase project, your users and data are safe regardless of the code. If you own the store accounts, your listing, reviews, and install base survive a rebuilt binary.
A rebuild from a working reference app is also dramatically cheaper than the original build — the product decisions are made, the screens exist to copy, and the backend often carries over untouched. We regularly rebuild 'lost' MVPs in a third of the original timeline for exactly this reason.
Assess before you re-hire: the audit step founders skip
Whatever you recovered, resist handing it straight to the next developer with 'finish this'. You don't yet know whether the codebase is 80% done or 80% unusable — and neither will a new hire quoting blind. An independent takeover audit (a few days, a written report) answers what exists, what works, what's risky, and what finishing actually costs.
The audit also converts your next hiring conversation from hope to specification: every candidate bids on the same documented reality, which is exactly the protection you didn't have the first time.
Make it structurally impossible to happen again
The founders who go through this once set up their next engagement so silence can't hold the project hostage:
• Every account — stores, backend, repo, domains — created under YOUR email, with the developer added as a member
• Code pushed to your repository from day one, not delivered at milestones
• Weekly installable builds on your own phone — progress you can't touch isn't progress
• Payments mapped to demonstrated milestones, never large sums up front
• The signing keystore (or Play App Signing) and all secrets stored in your password manager, not theirs
Founders also ask
Does the developer legally own my app's code? Usually no — if you paid for custom development under an agreement (even informal messages describing paid work-for-hire), the work product is yours in most jurisdictions. Practical possession matters more than legal theory, though, which is why the escalation path above focuses on making handover easier than holdout.
They want a final payment before handing anything over — should I pay? If real work was delivered and the amount matches the agreement, a simultaneous exchange is reasonable: payment releases as access transfers, ideally through a platform or escrow. Never pay first on a promise from someone who already went silent once.
How much does recovery cost? The audit runs free to a few hundred dollars. From there it depends on what survived: config-level fixes and finishing touches often land under $5,000; completing a half-built MVP typically runs $5,000–$20,000 — still usually far less than starting over, and you keep your users, data, and store history.
How do I know the next team won't do the same thing? You can't guarantee character, but you can remove the leverage: with your accounts, your repo, weekly builds, and milestone payments, a disappearing developer costs you days instead of months. Structure beats trust.