Technology Insights

App Redesign and Takeover: What to Audit First, Who Maintains It, and Whether You Need a Design System

When an app needs a redesign or a new team, the first step is not new screens but an audit: source code, App Store and Google Play developer accounts, signing keys, back-office and server access, and connected third-party services. Only after the audit, and after the new team proves it can rebuild and publish the app itself, does feature work begin. Agree on who maintains the app after the redesign up front; whether to build a design system depends on how many products you run and how often you change them, and only multi-platform products under continuous change justify a full one.

By Founder & CEO, JoinXPublished 7 min read
App Redesign and Takeover: What to Audit First, Who Maintains It, and Whether You Need a Design System

Key takeaways

  • The first step in an app redesign or takeover is an audit, not new screens: confirm you can get the source code, developer accounts, signing keys, server access and third-party services.
  • Have the new team prove it can rebuild and publish a small release on its own before changing features, so a live service is never interrupted.
  • Developer accounts are best held in the client's name; if they aren't, both Apple and Google support transferring an app between developer accounts while keeping ratings and download history.
  • Write who maintains the app after the redesign into the contract: iOS and Android change every year, store rules change too, and an app with no owner soon can't be updated.
  • Not every app needs a design system: a full one pays off for multiple products, multiple platforms and continuous change, while a single small app only needs basic UI guidelines.
Contents

When an app needs a redesign or a new team, the first step is an audit, not new screens. Confirm you can get the source code, developer accounts, signing keys, and back-office and server access, and that the new team can rebuild and publish the app itself, before changing features. Who maintains it afterward and whether to build a design system should also be decided before work starts.

Apps that come to us for a redesign or takeover usually fall into a few situations: the original developer no longer maintains it, in-house engineers have left, the screens and flows are so dated that users complain, or several apps need to be merged into one. Whichever it is, the order is much the same: gather everything, confirm you can publish, then decide what to change.

Should you make small changes, redesign, rewrite, or bring in a new team?

Check whether the code can still be changed safely and whether the problem is the interface or the foundation. Dated interface, healthy code: redesign. Unreadable code, outdated dependencies: consider a rewrite. Original team gone: take over and stabilize first, then decide.

ApproachWhen it fitsConfirm before starting
Small updateFlows mostly work; screens are dated or a few features are missingThe source code builds and a new version can be published
Major redesignUser flows need to be redesigned, or several apps mergedWhether the back office and API can be reused, and how data moves
RewriteThe technology is too old to meet store rules, or the code can't be changed safelyWhether anyone can explain the old app's business rules
New team takes overThe original developer no longer maintains it, or in-house engineers leftWhether source code, accounts, keys and server access are complete

A rewrite sounds cleanest, but relearning old rules, migrating data and running both systems in parallel are often underestimated. If an entire system has no one to maintain it, see our legacy system takeover guide, which covers health checks and how to decide between refactoring and rewriting.

What should you audit before a redesign or takeover?

Audit six areas: source code, developer accounts, signing keys and certificates, back office and servers, third-party services, and documentation and data. Accounts and keys cause the most trouble; without them, even a finished redesign can't be published.

  1. Source code and repositories: the complete source for iOS, Android, back office and API, including the exact version that is live, not an old backup.
  2. Developer accounts: whose name the Apple Developer and Google Play Console accounts are in, and who has admin access.
  3. Signing keys and certificates: the Android upload key and whether Play App Signing is used; push certificates or keys for iOS.
  4. Back office and servers: admin access to hosting, databases, domains and cloud accounts, and how deployment works.
  5. Third-party services: whose name the push, payment, maps, SMS and analytics accounts and contracts are in.
  6. Documentation and data: API docs, business rule notes, user feedback, crash logs and usage data.

Pay special attention to Android signing keys. Google explains that with Play App Signing, a lost upload key can be reset, but a self-managed app signing key cannot be reset once lost (Use Play App Signing). Checking this before a takeover saves a lot of trouble.

How do you take over a live app without interrupting service?

First have the new team rebuild and publish a small release with no feature changes, then start changing things. That step confirms the source code, accounts and keys are correct, giving later changes a safe starting point.

  1. Audit and handover: gather everything on the list above, record what is missing, and fill the gaps with the original vendor or your internal contact.
  2. Set up a repeatable build: rebuild in the new team's environment and confirm the app behaves like the live version.
  3. Publish a small release: fix only minor issues or update dependencies, and go through a full review and release.
  4. Scan and harden: before delivery we complete source code scanning and vulnerability scanning ourselves; when black-box testing is needed, a third party performs it, JoinX can help arrange it, and we fix the findings before delivery.
  5. Start the redesign: release in versions by priority, with a rollback path for each one.

If the developer accounts aren't in your company's name, both Apple and Google have a process for transferring an app between developer accounts. Apple says a transferred app keeps its ratings and reviews and users keep receiving updates (Overview of app transfer); Google Play has a matching transfer process. Move the accounts back into your own name when you change teams, so you don't get stuck next time.

Who maintains the app after the redesign?

There are three common setups: your in-house team maintains it, an external team maintains it, or your team owns requirements and acceptance while an external team develops and maintains. Whichever you choose, the contract should state the maintenance scope, support hours, response times, and whose name the source code and accounts are in.

SetupWho it suitsWhat to watch
In-house teamCompanies that already have iOS, Android and back-end engineersHandover documents when people change
External teamNo in-house engineering team, or the app isn't core businessKeep the source code and accounts in your own name
HybridAn in-house product owner with varying development volumeKeep a fixed contact for requirements and acceptance

Maintenance isn't "fix it when it breaks." iOS and Android ship a major release every year, and from August 31, 2026, Google Play requires new apps and updates to target Android 16 (API level 36) to be submitted (Android Developers). If no one tracks these rules, one day the app simply can't pass review. For how to budget maintenance, see App development cost.

Should a redesign include a design system?

It depends on how many products you run and how often you change them. If several apps and websites must stay consistent, or you redesign every quarter, a full design system is worth it; for a single, simple app, basic guidelines for color, type and components are enough.

A design system organizes color, typography, spacing and components into a shared set of guidelines and a component library. Its value comes later: new features or other platforms reuse the same components, the interface stays consistent, and nothing has to be designed from scratch each time.

SituationRecommendationWhy
One app, simple features, rare changesBasic UI guidelinesA full design system won't pay back its setup cost
One app, continuous changesStart with common components and expandThe more releases, the more effort shared components save
Several apps, or an app plus a websiteFull design systemKeeps products consistent and gives a common base for merging
Merging several appsBuild it before mergingUnify components and guidelines first so teams don't each do their own

For how we approach UI/UX and design systems, see our UI/UX design service.

How does JoinX handle app redesigns and takeovers?

We have taken over more than 100 projects built by others, following the order above: audit source code, store accounts, certificates and server access, confirm we can publish again, then start the redesign, and deliver the complete source code and deployment documents at handover.

On the app side, we consolidated the systems behind the China Motor Corporation owner app, and we handle outsourced development and maintenance of Capital Investment Trust's website, ETF website and app. For more on how we build and maintain apps, see our app development service.

Frequently Asked Questions

Can you take over an app without the source code?

First check whether the source code and legal rights can be obtained from the original vendor, a repository or a backup. With only the published install file and no source code, the original features usually can't be changed safely, and planning a rewrite is the more realistic path.

Does the app need to be republished after changing vendors?

No. With the source code, developer account access and signing keys, the new team can ship updates to the existing app, and its ratings and download history are kept. If the accounts aren't in your name, use Apple's and Google's transfer processes.

How much does an app redesign cost?

It depends on scope. An initial code and system health check before a takeover usually runs about NT$50K–200K; the redesign itself is quoted item by item, and you can use the tiers in our app development cost article as a reference. A rewrite equals building a new app and is quoted by the new scope.

How long does an app redesign take?

First allow time for the audit and for publishing a small release, then release the redesign in versions by scope. A small redesign can be done in a few releases; a major redesign or merger is best split into several phases that can each go live on their own.

Does every redesign need a design system?

No. A single, simple app only needs basic UI guidelines. A full design system is worth building when several apps or websites must stay consistent, or when you are merging several apps.

In whose name should developer accounts be registered?

Your company's. The developer account is where app ownership lives; if the app is published under a vendor's or an individual's account, changing teams later means going through a transfer.

Sources

  • Overview of app transferApple (App Store Connect Help)
  • Use Play App SigningGoogle (Play Console Help)
  • Transfer apps to a different developer accountGoogle (Play Console Help)
  • Meet Google Play's target API level requirementGoogle (Android Developers)

These are the regulations and sources cited at the time of writing. Rules may be revised; always check the latest official announcement.

About the author

Jack Lee

Founder & CEO, JoinX

Jack founded JoinX in 2016 and leads a team of 80+ people across Taiwan and Japan. JoinX has delivered 520+ projects for 220+ clients, including 56 mid-to-large systems.

Related articles