Developer disappeared. Agency went bust. Offshore team delivered something you can't ship. Whatever's gone wrong, we've seen it before. You start with a free check, then a £95 code review that's credited in full, and we quote the rescue once we've read the code.
50+ apps shipped since 2017
Every month we hear from founders and business owners whose app is stuck in limbo. The developer went quiet. The agency is no longer trading. The offshore team delivered something, but it doesn't work properly. The app is 95% done but nobody can finish it. The payments are broken and the original developer isn't responding.
These situations are more common than people think, and they're rarely the client's fault. Building software with unfamiliar teams is genuinely difficult, especially when there's pressure to move fast or save money. What matters is understanding where things are and what needs to happen next.
We've rescued apps from offshore disasters, agency insolvencies, and disappeared developers. In our experience, roughly half of the rescue enquiries we receive involve an offshore team that stopped communicating, and the other half involve a developer or agency that simply isn't around any more. If that sounds like your situation, you're in the right place.
Every rescue starts with a free check. Tell us what's happened and a person replies in writing with what we'd look at first. If it's worth going further, a £95 code review gives an engineer a fixed amount of time in your code or builder project to look at the architecture, security, stability and crash health, whether it can be saved, and who owns the code or builder project, and the accounts it runs on. You get a written report, and the £95 is credited in full against any paid work that follows. Here's what we typically deal with:
• Developer disappeared or unresponsive? We assess what exists, recover what we can, and plan the fix.
• Agency went bust or into administration? Source code recovery, liquidator liaison, full codebase takeover.
• Offshore team delivered broken code? We run a full code review and security audit, then decide whether to fix incrementally or start fresh.
• App Store keeps rejecting your app? We audit against the latest guidelines, fix the issues, and handle resubmission.
• Live app with broken payments or core features? Same-day triage, clear diagnosis, priority fix.
• No source code available? We assess whether decompilation is viable and scope a rebuild from the live app if not.
After the review we quote the rescue: a fixed price where the scope is clear, or a time-and-materials estimate where it isn't. You'll know what you're committing to before work starts.
Most clients then move to App Care with the same team, so nobody has to learn the codebase again. After a rescue, the first month of App Care's three-month initial term is included and the onboarding fee is waived, because we already know the code. Months two and three are billed at your plan's rate, from £675 a month.
App Rescue is for apps a developer or agency built for you, whatever tools they used. If you built the app yourself, in Lovable, Base44, Replit, Bolt.new, FlutterFlow, Bubble, Cursor, Claude Code or anything else, no-code to production is the better place to start.
Apps we rescue consistently achieve 99%+ crash-free sessions within weeks of handover.
Written by Gareth Reese, Founder and CTO of Foresight Mobile. Gareth has overseen app rescue projects for clients across the UK, including cases involving offshore team failures, agency insolvencies, and disappeared developers.
An actionable four-week plan with clear deliverables and an unbeatable £3,500 price point, credited against your first development sprint.
Total client time commitment: 5-7 hours across 4 weeks
We meet with your key stakeholders to understand your business goals, user needs, and technical constraints. You'll share any existing research, designs, or documentation you have.
Our engineering team assesses the technical feasibility, identifies integration points with your existing systems, and evaluates architecture options.
We determine whether Flutter, native development, or another approach makes the most sense for your specific requirements.
We create clickable prototypes so you can experience your app before it's built. You'll test navigation flows, validate the user experience, and gather feedback from stakeholders.
Alongside this, we prioritise features based on business value and technical complexity, mapping out a phased delivery plan with a detailed cost estimate.
You receive your complete Gameplan pack, plus a presentation walkthrough with Q&A. Your team walks away with everything needed to make a confident decision.
We start with a free check, then a £95 code review that tells you what's there and what it'll take to fix. We only quote the rescue after that.
Most clients who come to us for a rescue stay on App Care afterwards, because once we know the codebase we can look after it properly. After a rescue, the first month of App Care's three-month initial term is included and the onboarding fee is waived. Months two and three are billed at your plan's rate, from £675 a month, and it's rolling monthly after that.
The move is easy because it's the same people: the developer who fixed your broken Stripe integration is the one who monitors it afterwards, so nobody has to re-learn the code.
If you don't need ongoing support, that's fine too. After the rescue, all code, documentation, and credentials are yours. We don't hold anything hostage, and we don't create artificial dependencies. If you want to take the rescued app to an internal team or another agency, you can.
Same Team Continuity • Full Code Ownership • Documentation Handover • First Month of App Care Included
If your app is live and something critical is broken right now, that's not a normal enquiry. Payments failing. Push notifications not sending. The app crashing on the latest iOS. Users are affected and every hour costs money and reputation.
We treat live-app emergencies differently from standard rescue work. Get in touch, describe the issue and the technology involved, and we'll give you a realistic assessment within hours. If it can't wait, triage can start before the code review, and it's billed on time and materials. If we can help, we'll tell you what it'll take. If we can't (wrong technology, wrong timezone, genuinely beyond repair), we'll tell you that too.
For clients who come to us through an emergency, the natural next step is usually an App Care retainer once the immediate crisis is resolved. Same team, no re-learning required. You go from "everything is on fire" to "someone reliable is looking after this" in a matter of days.
Same-Day Assessment • Priority Scheduling • Honest Viability Check • Transition to App Care
A rejected app doesn't mean a broken app. We've resolved Guideline 4.3 (spam/clone) issues, privacy manifest rejections, SDK compliance failures, and metadata policy violations, often with minimal code changes.
App Store rejections are common. Apple's own App Store Transparency Report shows roughly 1.9 million of 7.8 million submissions were rejected, with crashes and performance failures the biggest single cause and privacy manifest issues the fastest-growing category. Most are fixable, often with minimal code changes.
Google Play rejections follow a similar pattern: policy changes around data safety declarations, target API level requirements, and content compliance. We handle both platforms.
The key is understanding what Apple or Google actually wants (which isn't always what the rejection message says) and making the minimum changes needed to get through review. We don't over-engineer the fix.
Apple Guideline 4.3 Resolution • Privacy Manifest Compliance • Google Play Policy Fixes • Resubmission Support
A messy codebase doesn't always mean starting from scratch. Problems like missing error handling, poor security practices, and inconsistent code quality are fixable without a full rewrite.
We assess what's salvageable and what isn't. For codebases worth building on, the fixes tend to be specific: security remediation, adding test coverage, version control discipline, and documentation. When a clean rewrite using the existing app as a reference is faster and safer than patching, we'll tell you that too.
What we won't do is make you feel bad about hiring offshore in the first place. Budget pressures are real. Recommendations don't always work out. What matters now is getting the app to where it needs to be.
Codebase Assessment • Incremental Fix vs Rewrite • Security Remediation • Documentation
Lost your source code? It's more common than you'd think. Agencies go into administration without handing over assets. Developers become possessive or unresponsive. Freelancers vanish. We've dealt with all of these situations.
If the app is on the App Store or Google Play, we can often work with a compiled build. The quality of what we can recover depends on the technology used and what protections were applied, but decompilation frequently gives us enough to understand the architecture and build from. If the agency used GitHub, GitLab, or Bitbucket, you may still have access without realising it. Liquidators sometimes release source code as part of the insolvency process, and we can advise on what to ask for.
Where source code genuinely can't be recovered, we'll scope a rebuild using the existing app as a working specification. You already know what the app should do. That's half the battle.
Decompilation Assessment • Repository Recovery • Liquidator Liaison • Rebuild Scoping
We don't quote blind. The first step costs nothing: tell us what's gone wrong and a person replies in writing with what we'd look at first.
If it's worth going further, give us access to the code or builder project. For £95, an engineer spends a fixed amount of review time on the architecture, security, stability and crash health, and whether it's worth saving. The review also checks who owns the code or builder project, and the accounts the app runs on. You get the findings in writing, with a ranked list of specific issues, and the £95 is credited in full against any paid work that follows. If the review shows a rescue isn't viable, we keep the £95, since it paid for that written verdict.
From there we quote the rescue at a fixed price where the scope is clear, or a time-and-materials estimate where the unknowns are too big to price up front.
Free Check • £95 Code Review • Credited in Full • Fixed Price Where Scope Is ClearIt depends on who wrote the code. If you built the app yourself, in any tool including Cursor or Claude Code, start with no-code to production. If a developer or agency wrote it, with or without AI tools, App Rescue is the right service. Both start with a free check, so if you're not sure, tell us how the app was made and we'll point you to the right one.
No. We see situations like this every week and the circumstances are almost always understandable: budget pressures, using an agency based on a recommendation, a developer who was fine for the first few months and then wasn't. What matters to us is understanding where things are and what needs to happen next, not scoring points about how it got here. You'll get a straight, practical assessment.
A single-commit codebase is more common than you'd think. We see it regularly with offshore and freelance platform projects. The lack of version history makes it harder to understand what changed and when, and means we can't roll back to an earlier working state. But it doesn't necessarily mean the code is unworkable. The code review will tell us whether the logic is sound, what the security posture is, and whether it's worth building on. Sometimes it is. Sometimes a clean rewrite from the existing codebase as a reference is faster. We'll tell you which.
It starts with a free check. Tell us what's happened and a person replies in writing with what we'd look at first.
If it's worth going further, a code review costs £95. An engineer spends a fixed amount of time reading your code or builder project and sends a written report on the architecture, security, stability and crash health, whether it can be saved, and who owns the code or builder project, and the accounts it runs on. The £95 is credited in full against any paid work that follows. If the review shows the rescue isn't viable, we keep the £95, because it paid for that written verdict.
If a live app is failing and can't wait, triage can start before the review, billed on time and materials. Otherwise we quote the rescue after the review: a fixed price where the scope is clear, or a time-and-materials estimate where it isn't. We don't publish a price range, because one rescue might be a single broken payment flow and another a whole app with no documentation. If you'd like us to look after the app afterwards, the first month of App Care's three-month initial term is included and the onboarding fee is waived. Months two and three are billed at your plan's rate, from £675 a month.
Yes. App Store rejections are frustrating but usually solvable. Apple's guidelines change regularly, and what got approved two years ago may not pass today. Common rejection reasons we deal with include Guideline 4.3 (spam or clone apps), privacy manifest compliance, outdated SDK versions, and data handling disclosures. We'll review the rejection reason, audit the relevant parts of the app, and advise on what needs to change before resubmission.
If payments are failing or a core feature is down, that's urgent and we treat it that way. Get in touch, describe the issue and the technology involved, and we'll give you a realistic assessment within hours. Triage can start straight away, before the code review, and it's billed on time and materials. We don't put rescue enquiries into a standard sales queue.
First, try to recover the source code. If the agency used a third-party repository (GitHub, GitLab, Bitbucket), you may still have access. If not, check whether the app exists as a compiled build anywhere, as that may allow partial recovery. Liquidators sometimes release source code as part of the insolvency process, and it's worth asking your solicitor or the appointed insolvency practitioner specifically about IP assets. If none of that works, get in touch. We can assess whether reverse engineering is viable and what it would cost.
Not necessarily. We always start with a code review to understand what's salvageable. Often the architecture is fine and we can fix issues incrementally. When the codebase is genuinely unsalvageable (no version history, security vulnerabilities throughout, no documentation whatsoever), a rewrite is sometimes faster and safer than patching. We'll give you a straight answer either way. We won't recommend a full rewrite unless it's genuinely the right call.
This is unfortunately common. If you paid for the code to be built, you should legally own it, but getting it back can take time. In some cases, a solicitor's letter resolves it quickly. In others, the practical route is to extract a recoverable version from a compiled build and start from there. We can walk you through what's realistic for your specific situation, including whether the IP is clearly yours and what recovery options exist.
Sometimes, yes. If the app is on the App Store or Google Play, we can often decompile or reverse-engineer a compiled build to get a working starting point. The quality of what we can recover depends on the technology used and what's available. We'll give you an honest assessment before we quote. If the review shows the rescue isn't viable, we'll say so in writing, and we keep the £95 because it paid for that verdict.
App rescue is the process of taking over an app project that's stuck, broken, or abandoned. We review what exists, fix what's broken, and get it to a state where it works. You probably need it if your developer has gone quiet or is unresponsive; your app is nearly done but nobody can finish it; payments or critical features are broken; your agency is no longer trading; or you've been handed a codebase with no documentation and no idea what's running where.
It's for apps a developer or agency built for you, whatever tools they used. If you built the app yourself, with Lovable, Base44, Cursor or any other tool, see no-code to production instead.
Developer gone quiet. Agency into administration. Offshore team delivered something you can't ship. These situations are more common than people think, and they're rarely your fault. What matters now is understanding what you've got and what it'll take to fix it.
Every rescue starts with a free check from a person. If there's more to find, a £95 code review tells you what's salvageable and what isn't, and the £95 is credited in full against any paid work that follows. We quote the rescue after the review, at a fixed price where the scope is clear and on time and materials where it isn't. If you built the app yourself, with Lovable, Base44, Cursor or any other tool, no-code to production is the better fit.
Get in touch, describe the issue, and tell us what technology is involved. If payments are failing or a critical feature is down on a live app, we prioritise the conversation and give you a realistic assessment within hours. We don't need a project brief at this stage. We need to understand the severity, what you have access to (repository or builder project, credentials, compiled builds), and whether it's urgent enough to start triage before the code review. Urgent triage is billed on time and materials.
The review is time-boxed: in a fixed amount of time, an engineer looks at the architecture, security, stability and crash health, the version history (or the lack of it), and whether it's worth saving. Where the app is still running, we use Sentry and Firebase Crashlytics to see live crash patterns. We also check who owns the code or builder project, and the accounts the app runs on. The report tells you whether to fix incrementally or rewrite, and we quote the rescue from what we found: a fixed price where the scope is clear, or a time-and-materials estimate where it isn't. If a rescue isn't viable, the report says so.
We fix critical issues first: broken Stripe integrations, failing authentication, App Store compliance rejections, outdated SDK versions. For codebases worth salvaging, we work incrementally. Where a rewrite is faster and safer than patching, we say so clearly and quote it, at a fixed price where the scope is clear. All work goes through Git with proper branching, code review, and TestFlight or Firebase App Distribution for staged testing.
We don't create artificial dependencies or hold anything back. If you want to take the rescued app to an internal team or another agency, you can do that with full documentation and a clean handover. If you'd rather stay with the team that now knows the codebase, most rescue clients move to App Care with the same developers, so nobody has to re-learn the code. After a rescue, the first month of App Care's three-month initial term is included and the onboarding fee is waived. Months two and three are billed at your plan's rate, from £675 a month.
Your app, your way. Here's how we make it happen
Every rescue starts with a free check and a time-boxed £95 code review covering architecture, security, stability, crash health, and who owns the code or builder project and the accounts it runs on. You get a written report before the rescue is quoted, so you know what you're deciding on.
After a rescue, most clients move to App Care so the problems that caused the crisis don't come back. The first month of the three-month initial term is included and the onboarding fee is waived, and you keep the team who ran the rescue.
A rescue isn't just about making the app build again. It's about making it reliable for the people who use it. We measure success by crash-free session rates, not by whether it compiles.
You know the history of the app: what it was supposed to do and what went wrong. We know how to reverse-engineer a codebase, triage the real issues from the symptoms, and sequence fixes so you can ship again without breaking everything else.
Our rescue audit methodology covers codebase structure, dependency audit, security, performance profiling, and App Store compliance. We've rescued apps with no documentation, departed developers, and zero test coverage. In our experience, 80% of rescue apps can be stabilised within six weeks.
We're based in Manchester with offices in London and Birmingham. App rescues often involve sensitive conversations. We think those go better in person. Drop in whenever you like.
Before Foresight came on board, we had crash reporting installed but it wasn't telling us anything useful. We knew the app had issues but couldn't see where they were coming from. Within weeks of the engagement starting, we had a proper picture of what was happening in production and could start working through the backlog. The difference was immediate.
“They’re more thoughtful than any other development team I’ve worked with..... I’m not sure what they could improve."
"The team has delivered exactly what we asked for but is able to use their own skill and judgment to make improvements"
"Foresight Mobile effectively and promptly met our needs. They were a candid, reliable, and collaborative partner."
