How to test a mobile app before launch: a practical plan
Build a mobile launch test plan covering critical flows, supported devices, test data, failure cases, accessibility and regression checks.
Testing is where launches are won or lost, and where budgets get cut first. This guide gives you a plan you can ask your team to follow and check.
Why not only tap through it by hand
Android's testing documentation (https://developer.android.com/training/testing/fundamentals) says you can test manually on different devices and emulators, change the system language and try to produce every user error. It also says manual testing scales poorly and regressions are easy to miss, while automated tests are faster, more repeatable and usually give earlier, more actionable feedback. Use both.
Four kinds of test, by subject (from the Android docs)
| Subject | The question it answers |
|---|---|
| Functional | Does the app do what it should? |
| Performance | Does it do it quickly and efficiently? |
| Accessibility | Does it work with accessibility services? |
| Compatibility | Does it work on every device and OS version you support? |
Three sizes of test, by scope
- Small (unit) tests check one method or class.
- Medium tests check how two or more units work together.
- Big (end-to-end) tests check a whole screen or user flow.
The same page distinguishes where tests run: instrumented tests run on a real or emulated device, usually UI tests; local tests run on a development machine or server and are usually small and fast. It also warns that code which is hard to test in isolation leads to bigger, slower, flakier tests and fewer scenarios covered.
Where to run each test: Android's testing strategy page
A second Android page, "Testing strategies" (https://developer.android.com/training/testing/fundamentals/strategies, read 15 Nov 2026), adds:
- A good strategy catches issues early, runs quickly and shows clearly what needs fixing. It says its guidance is a baseline, not strict rules.
- The pyramid. Small tests are fast and reliable; big tests have more fidelity (closeness to the production environment) but are harder to maintain. Most apps should have many small tests and few big ones. Camera or media apps may differ because of hardware needs.
- Cost of a bug. A bug caught by a unit test is typically fixed in minutes. The page says an end-to-end test could take days to find the same bug, and a bug that reaches production can take a long time, sometimes weeks, to reach users' devices. It still says an imperfect strategy beats none.
- Five layers (one possible split, since the categories have no precise definitions): unit, component, feature, application and release candidate. The release candidate layer tests the minified, optimised release build in an environment as close to production as possible without exposing real user accounts or public backends. The page's table pairs layers with network access (none for unit and component, mocked for feature, staging or production for later layers) and timing (pre-merge for the small layers, post-merge or pre-release for the big ones).
- Choosing a layer. Use the lowest layer that gives the team the feedback it needs; its sign-in example puts the form validator logic in unit tests and the full sign-in journey against a staging server in release candidate tests. It also says manual testing, such as exploratory testing by a QA team, can be part of the strategy.
- Write it down. A shared strategy document defines the layers, goals, priorities and who owns each test category.
Two more Android pages describe where tests live: local unit tests run on your workstation's JVM, quickly but without the Android framework (https://developer.android.com/training/testing/local-tests); instrumented tests run on a physical or emulated device with more fidelity but much more slowly, and the page recommends them only when you must test against real device behaviour (https://developer.android.com/training/testing/instrumented-tests). Both pages were read in part for their setup sections.
A launch test plan (our template)
- Decide the critical flows. For a delivery app: sign up, search, add to cart, pay, track, cancel. Write them as numbered steps.
- Define pass/fail for each flow. Example: "A new user can place an order in under 2 minutes with no error."
- Pick the device matrix. List the oldest OS version you will support, one mid-range phone, one small screen and one large screen. Base the list on your own expected audience, not a generic one.
- Use test data only. Run payment and order tests in a sandbox or test mode with test payment methods and test accounts. Never use real customers' orders, cards or personal data to test. Confirm the test environment cannot reach real payment accounts, and clear test data afterwards.
- Test the unhappy paths. Airplane mode mid-checkout. Wrong card. App killed during payment. Denied permissions. Phone language changed.
- Run accessibility checks. Larger text, a screen reader, sufficient contrast.
- Run a performance pass. Cold start, a slow network, a long list.
- Automate the critical flows so they run before every release.
- Hold a release gate. Nothing ships with an open failure on a critical flow.
A tracking table you can copy
| Flow | Device/OS | Result | Defect ID | Retested |
|---|---|---|---|---|
| Place order | oldest supported OS | |||
| Place order | small screen | |||
| Pay with failed test card (sandbox) | mid-range phone |
What to ask your development team
- Which flows are automated, and which are manual?
- Which devices did we test on, and why those?
- How long does the full regression run take?
- Who decides whether a known defect blocks release?
Limits
The testing taxonomy and strategy come from Android's documentation; iOS has its own tools, which we did not read (Apple's testing page did not load for us). We did not benchmark any testing tool. The plan template is our practical guidance, not a standard.
By Omnistu.