Taking over a badly built app: where to start?
Taking over a badly built app: warning signs, access to secure, code audit, stabilize or rebuild, and how to switch development provider without disruption.
Published on November 20, 2026 · 7 min read
Taking over an app that was badly built always starts with the same step: secure access (source code, hosting, app store accounts, third-party services), then commission a code audit before touching anything. That assessment is what lets you decide, objectively, whether to stabilize, progressively rebuild or, less often, rewrite. A well-run takeover of an existing app happens without interrupting your users' day-to-day work.
In this article, we cover the signs that an app is poorly built, what to recover first, what a code audit includes, how to choose between the available options and how a takeover actually unfolds.
How can you tell your app is badly built?
A badly built app first shows itself through business symptoms, long before anyone reads a line of code. If several of the following signals sound familiar, it is time for a diagnosis.
- Recurring bugs: the same problems come back after every fix, or new ones appear with each update.
- Slowness that keeps getting worse: screens that take ages to load, failed syncs, an app that crashes for no apparent reason.
- Every change breaks something else: adding a simple feature becomes slow, expensive and risky.
- Outdated dependencies: libraries and frameworks never updated, to the point where the app stores or the hosting provider eventually force an upgrade.
- No automated tests: nobody can say for sure whether a change has side effects.
- An unreachable provider: response times get longer, contacts keep changing, quotes are impossible to understand.
- No access to the code: you do not know where the repository is hosted or who owns it.
None of these signals condemns the app on its own. But when they pile up, they almost always point to a deeper problem: fragile architecture, heavy technical debt or no real development process.
The access to secure before switching provider
The first thing to do when taking over an app is to recover every access that lets you run it without depending on the previous provider. Until that access is in your hands, any takeover remains fragile.
Here is the checklist:
- The source code repository: all the code, with its history, on a platform where your company owns the account.
- App store accounts: Apple App Store and Google Play developer accounts in your company's name, not the provider's.
- Hosting and infrastructure: admin access to servers, cloud services, databases and backups.
- Domain names and certificates: the registrar, DNS settings and associated technical email addresses.
- Third-party services: payments, email delivery, notifications, maps, analytics, error tracking tools, with the matching API keys.
- Documentation: architecture diagrams, deployment procedures, environment variables, test accounts.
A good habit: take stock of all this access before you even announce the change of provider. A transition always goes more smoothly when you know exactly what you need to recover.
On the contract side, check the clauses on code ownership and the transfer of rights. They determine what you can require from your previous provider during the handover.
The code audit: what gets reviewed and why
A code audit is a complete technical assessment of the app, carried out before any work begins. It answers a simple question: what do we keep, what do we fix, what do we rebuild?
A serious audit covers several dimensions:
- Architecture: is the overall structure of the code consistent, are responsibilities clearly separated, can it evolve?
- Code quality: readability, conventions, duplication, complexity of the critical parts.
- Security: authentication, protection of sensitive data, secrets exposed in the code, known vulnerabilities.
- Dependencies: framework and library versions, abandoned or vulnerable packages.
- Tests: whether automated tests exist, whether they are relevant, and whether critical user flows are covered.
- Performance: load times, expensive queries, resource consumption.
- Infrastructure and deployment: hosting, backups, monitoring, release process.
- Data: database structure, consistency, migrations, GDPR compliance.
The expected deliverable is a written document a business leader can understand, with a list of workstreams prioritized by risk and impact. Be wary of an audit that systematically concludes everything must be rebuilt without justifying it point by point.
Stabilize, rebuild or rewrite: how to decide?
The right decision depends on the audit's findings, not on a technical preference. There are three main options, and they are often combined.
Stabilize what exists
You fix critical bugs, update dependencies, harden security and add tests on the essential user flows. This is the option to favor when the architecture is sound but the code has been poorly maintained.
- Pros: fast, low risk, no disruption to the business.
- Limits: does not solve a deep architectural problem.
Rebuild progressively
You replace the most fragile parts one by one while keeping the app live. Each rebuilt module is tested and released before moving on to the next.
- Pros: your users keep working, the budget is spread over time, each step brings a visible improvement.
- Limits: requires careful coordination between old and new code during the transition.
Rewrite from scratch
You start from a blank page and rebuild the app. It is sometimes necessary, for example when the technology is no longer maintained or the code is unusable.
- Pros: a clean, modern technical foundation.
- Limits: long, expensive, and the product is frozen for the entire duration of the rewrite.
Why the "big bang" is risky
A full rewrite delivered all at once stacks up risks: forgotten features, implicit business rules lost along the way, tricky data migration, users thrown off on switchover day. Meanwhile, the old app still needs maintenance. That is why a progressive rebuild is almost always the safest path when taking over an existing app.
How does an app takeover work in practice?
A successful takeover follows a clear sequence of steps that secures the product before evolving it. Here is the typical flow.
- Handover: recovering access, getting familiar with the environment, setting up a controlled deployment process. The goal is to be able to ship a fix safely.
- Audit and plan: a written assessment, prioritized workstreams, effort estimates.
- Quick wins: fast, high-impact fixes such as a blocking bug, a security flaw or an annoying slowdown. They reassure users and give the project visibility.
- Stabilization plan: dependency updates, added tests, monitoring and alerts, verified backups. This is often where DevOps work on infrastructure and continuous integration comes in.
- Progressive rebuild: replacing fragile modules and, if needed, redesigning the UX of the most used flows.
- Maintenance and evolution: fixes, version upgrades and new features, with a steady release pace.
At Lunify, app takeover and redesign follows this logic: an audit before touching the code, then a progressive rebuild rather than a big bang.
Switching provider: how do you make sure it does not happen again?
The best way to avoid another painful takeover is to set clear rules on transparency and quality with your provider from day one. A few simple requirements make a big difference:
- Accounts in your name: code repository, app stores, hosting and third-party services belong to your company from the very first day.
- Permanent access to the code: you can look at the repository at any time, without having to ask.
- A visible development process: sprints, code reviews, automated tests, reproducible deployments, as described in our build phase.
- Up-to-date documentation: architecture, deployment procedures, key technical decisions.
- Regular progress updates: demos, shared priorities, estimates that come with explanations.
These criteria are also good filters when you choose an app development agency. A provider who accepts them without hesitation is usually a provider with nothing to hide.
Taking over an app: the key points
Taking over a badly built app is neither a dead end nor necessarily a reason to start over. The approach comes down to a few principles: secure access, get the code audited, decide based on facts, stabilize before rebuilding, and move forward in steps rather than with a single switchover. Done well, a takeover turns an app that holds your business back into a reliable product you can finally evolve.
Is your app unstable, or stuck with a previous provider? Let's talk: we will help you assess where it stands and define the right takeover plan.
Frequently asked questions
Related articles
November 20, 2026 · 6 min read
Mobile app development cost: what drives the price in 2026
Mobile app development cost explained: scope, platforms, design, back end, AI and maintenance. What drives the price and how to get a reliable quote.
November 22, 2026 · 5 min read
SSII vs ESN: What's the Difference and Why the Name Changed (History, Missions and Client Impact)
SSII vs ESN: what's the real difference? Learn why the name changed, how the profession evolved, and what it means when choosing a digital partner.
November 20, 2026 · 7 min read
App requirements document: outline, content and mistakes to avoid
How to write an app requirements document for a mobile or web app: a reusable outline, what each section covers, user stories and common mistakes to avoid.
A project in mind? Let’s talk about it.
Startup, SME or large group, whatever your industry: we help you frame the need and build the right product.