← Blog

Mobile app upgrade testing: a checklist for existing installs

By Edward Harker

To test a mobile app upgrade, install an older supported version, create representative data in that version, then update it without uninstalling or clearing its data. Check the first launch and use the saved data to complete a real task. Repeat for supported paths that skip releases, and record both build numbers with each result.

A clean install doesn't exercise the same starting state. Apple's release-build testing guide specifically calls for testing app updates with data from prior versions, including changed file formats and database migrations.

Which upgrade paths should you test?

Begin with the version currently in production and the candidate you plan to ship. Add an older supported starting version when it creates different stored data, crosses a storage change, or represents a group of users who haven't updated recently. Ask engineering which paths the new build supports; don't infer that every historical version must work.

For example, a fictional notes app might need these runs:

Starting installData prepared before updatingUpdate toWhat the run checks
Current production build 540Two saved notes, one unsent edit, signed-in test accountCandidate 560The usual update with unfinished work
Older supported build 510Notes created before an attachment-format changeCandidate 560, skipping 540An older data format still opens and can be edited
Current production build 540Signed-out account, changed text-size preferenceCandidate 560Signed-out startup and a retained setting

Version names alone can hide different binaries. Record version and build number, device, OS, distribution channel and test environment. Use the mobile device test matrix to assign the paths to phones. If an old binary is unavailable or cannot update through the intended route, mark that path Blocked and name what's missing.

How do you prepare an existing installation?

Create the test data using the old app itself. Inserting a few records into the new build doesn't show whether it can read everything the old build wrote.

  1. Install the chosen starting build on a test device. Confirm the version and build number.
  2. Use a test account to create recognisable records: a named draft, a saved item, a download or another object affected by this release. Note which data is stored locally and which is already on the server.
  3. Set up the account, preferences and unfinished work for this case. For a queued-action test, confirm the action is still pending before updating.
  4. Capture the starting result with sanitised screenshots or a short record of the data. Close and reopen the old app to confirm the items were saved.
  5. Update to the candidate through the agreed distribution route, without deleting the app or clearing its data. Record any extra installation step.

On Android, a candidate with a different application ID installs as a separate app. Android also checks signing compatibility and version code before accepting an update; see how app updates work. If a debug build cannot replace a store-signed app, get a compatible candidate from the release owner. Uninstalling to bypass the error removes the starting installation you needed to test.

On iOS, use the team's supported update route and record it, whether that's TestFlight or another approved distribution method. Launch the candidate from the home screen without an attached debugger for the user-facing run. Apple explains that a debugger can change suspension and hang behaviour in its release-build testing guide.

What should the upgrade checklist cover?

Agree expected results before running the update. A session may deliberately require a new login; downloaded content may deliberately need fetching again. The case should say what the user sees and what happens to their work under that policy.

CheckAction after updatingEvidence to record
First launchOpen the app and wait for startup to finish; open it again after closing itWhether startup completes, any message and the observed wait
Existing recordsOpen, edit and save an item created by the old buildIts content before and after the update, then after reopening
Account stateUse a feature that makes an authenticated requestCorrect account, successful request or the agreed login flow
PreferencesRevisit settings changed in the old versionRetained choices, or the documented change the user sees
Pending workOpen a draft or resume a queued action; reconnect if this case requires itWhether the work remains available and the resulting server record
Downloads and filesOpen content downloaded or attached before the updateReadable content or the expected recovery step
Continued useCreate a new item, then reopen both old and new itemsBoth remain usable after another launch

For queued work, check the final server result as well as the screen. A cleared spinner doesn't tell you whether an edit was lost or an upload was submitted twice. Use test data that you can identify in the test backend, and record the expected number of resulting records.

Choose additional conditions from the change. If startup now migrates a large local database, prepare a larger supported dataset. If the migration needs a connection, test the agreed offline recovery and return online. Keep installation failure, failure during first launch and a later sync failure as separate cases: each needs a different starting point to reproduce it.

How do database migration tests fit into the QA run?

Ask engineering for automated checks of the storage paths involved, alongside the device run. For Android apps using Room, Google's migration guide describes migration tests and recommends covering the full migration chain. Its helper validates schema changes; the test still needs assertions that the data migrated correctly.

On the device, check what the user can do with that data. A database can have the expected columns while a saved note opens with the wrong attachment or an old draft can no longer be submitted. Keep a concrete task in the case, such as “open the old note, change its title, save it and find it again after relaunch”.

After the upgrade checks, run the related journeys selected for mobile app regression testing. Record the starting version on any regression result that depends on upgraded data.

What should you capture when an update fails?

Keep the failing device in its current state until you've captured the evidence. Clearing data may make the app usable while removing the only copy of the old record that triggered the bug. For another attempt, recreate the same starting installation and data on a separate test device where possible. Don't assume installing an older binary reverses a data migration.

Use this report template:

Title: [What failed] after updating [old build] to [candidate]

Device / OS:
Old version and build:
Candidate version and build:
Distribution route / environment:
Earlier upgrade history, if known:

Account state before update:
Data created in old build:
Pending work / network state:

Steps to prepare the old installation:
Steps to update and trigger the failure:
Expected result:
Actual result:
First launch only, or still present after reopening:

Screenshot / recording / relevant log excerpt and timestamp:
Attempts from the same starting state:
Clean-install comparison, if tested:
Device state preserved, or changes made since failure:

An illustrative title is “Saved note opens blank after updating 510 → 560; new notes still open”. The report should identify the note prepared on 510, show what it contained and describe what happened on the first launch of 560. A successful clean-install comparison is useful supporting evidence; it doesn't resolve the failed upgrade.

Use the bug report template generator to format the failed case for your tracker. Keep the old build and data-preparation steps in the reproduction text so the developer can set up the same installation.

Frequently asked questions

What is mobile app upgrade testing?

Mobile app upgrade testing checks an update installed over an older version with existing data. It covers first launch, stored records, account state, settings and any unfinished work the product promises to keep. Record both build numbers and the installation route beside the result.

Which older app versions should we test?

Start with the current production version, then add older versions that exercise a different supported migration path or represent users who skipped releases. Choose them using version adoption and storage changes. Record any supported path you could not test as a coverage gap.

Does reinstalling the app reproduce an upgrade?

No. Deleting the app changes its stored state, so reinstalling does not reproduce updating an existing installation. It is also unsafe to assume reinstalling creates a completely empty state: iOS keychain data can survive deletion. Keep fresh-install, reinstall and upgrade results separate.