Skip to content
D-bug Station

Taking Over an App Another Team Built

3 min read
  • Mobile
  • Maintenance
  • Process

Before anyone promises new features on an inherited app, someone has to find out whether it builds.

Apps change hands all the time: a freelancer moves on, an agency relationship ends, an in-house developer leaves. The new team inherits code it did not write and decisions nobody wrote down. The first weeks decide whether the handover goes smoothly, and they should be spent on facts, not promises.

Secure the access first

Before anything technical, make sure the business owns and controls everything the app needs: the source code repository, the Apple and Google developer accounts, signing keys and certificates, the servers and cloud accounts, the domain, third-party services such as payments, maps and push notifications. Losing access to a signing key or a developer account can block updates entirely, and it is far easier to sort out while the previous team is still reachable.

Get it building

The first technical milestone is unexciting: build the app from source, on a clean machine, and run it against a test environment. It is common to find missing configuration, outdated dependencies, or code on someone's laptop that never reached the repository. Until the app builds, every estimate is a guess.

Audit before promising

A short technical audit should answer a handful of questions:

  • How old are the frameworks and dependencies, and what will the next iOS or Android release break?
  • Where does it crash, and how often? Is crash reporting even installed?
  • How is data stored and secured? Are secrets in the code?
  • Is there any automated testing or release process?
  • Which parts are fragile, and which are sound?

Stabilise before adding features

The temptation is to show progress with new features. Fixing crashes, updating dependencies and setting up a release pipeline first makes every later feature cheaper and safer, and it is the work users notice most: an app that stops crashing.

Repair or rewrite

Rewrites are tempting and expensive. Decide with evidence from the audit: if the foundations (data model, architecture, framework) are sound, repair is almost always better. A rewrite makes sense when the platform is obsolete or the core is so tangled that every change breaks something else, and even then it is often done in stages.

We start every inherited project with exactly this kind of audit, so both sides know what is there before committing. If you have an app that needs a new team, tell us about it; our notes on maintenance cover what keeps it healthy afterwards.

Building something along these lines?