Key takeaways
- Mobile apps run on a fragmented set of devices, screen sizes and OS versions, in hostile conditions: calls, notifications, weak networks, low battery, the app being killed in the background.
- Choose devices from real usage data, combine emulators and simulators (fast, cheap) with real devices (the truth), and use cloud device farms for breadth.
- Test the full life of the app: install, update with existing data, permissions, interruptions, offline, and the store release process, not just the screens.
Where this picks up
You know how to design tests and test web UIs. Mobile adds a layer of variables you don't control: the device, the OS, the network, and what the user is doing while your app is open.
Types of mobile apps matter for what you test:
| Type | What it is | Testing implications |
|---|---|---|
| Native | Built for iOS or Android with platform tools (Swift, Kotlin) | Full device features; two separate apps to test |
| Cross-platform | One codebase for both (Flutter, React Native) | Shared logic, but platform-specific bugs still appear |
| Mobile web / PWA | A website in the phone's browser | Browser and screen-size issues; fewer device features |
Fragmentation: choosing devices
You can't test every device. Choose with data:
- Get your analytics: which devices, OS versions and screen sizes your users actually have.
- Cover the top devices that make up most of your traffic, plus the oldest supported OS version on each platform.
- Add edge cases: a small screen, a large tablet, a low-memory Android phone, a device with a notch or foldable screen if your users have them.
- Revisit the list every few months; new OS versions arrive yearly.
Emulators, simulators, real devices, cloud
| Option | Good for | Limits |
|---|---|---|
| Android emulator / iOS simulator | Fast feedback, debugging, automation in CI | Not real hardware: performance, camera, sensors, some OS behaviour differ |
| Real devices in the office | Touch, performance, camera, real networks | Costly; limited set |
| Cloud device farms (BrowserStack, Sauce Labs, AWS Device Farm, Firebase Test Lab) | Breadth: hundreds of real devices on demand | Cost; remote latency; less hands-on exploration |
A common pattern: automated checks on emulators for every build, cloud devices for broader regression, and real devices in hand for exploratory testing.
What to test that web testing doesn't cover
Interruptions and app lifecycle
- An incoming call, an alarm or a notification mid-flow.
- Switching to another app and back; locking and unlocking the screen.
- The OS killing the app in the background to free memory, then the user returning. Is the form data still there?
- Rotating the device mid-task.
Network conditions
- Weak signal, switching from Wi-Fi to mobile data, airplane mode mid-request.
- What does the user see while waiting? Is a payment sent twice if the user taps again?
- Offline mode, if the app has one: does data sync correctly when the connection returns?
Permissions
- First launch: are permission requests (location, camera, notifications) explained and asked at the right moment?
- What happens if the user denies a permission, or revokes it later in Settings?
Install, update, uninstall
- Fresh install and update from the previous store version with existing data. Updates are where migrations break.
- Is the user still logged in after an update? Are drafts, settings and offline data preserved?
- Minimum OS version: what happens on an unsupported device?
Device features and settings
- Screen sizes, notches, dark mode, large font sizes, different languages and right-to-left layouts.
- Accessibility with VoiceOver (iOS) and TalkBack (Android). See accessibility testing.
- Gestures: swipe, long press, pinch; the Android back button and gesture navigation.
- Push notifications and deep links: does tapping a notification open the right screen, even when the app is closed or logged out?
Performance and resources
- App start time, scrolling smoothness, memory use on older phones.
- Battery drain and data usage, especially for apps using location or background sync.
Releases and the stores
Mobile releases are slower to undo than web releases: users must update, and many don't. So:
- Test release builds, not just debug builds; they're configured differently.
- Use beta channels: TestFlight (iOS) and Google Play testing tracks (internal, closed, open).
- Many teams use staged rollouts, releasing to a small percentage of users first, and watch crash reporting (such as Firebase Crashlytics) before going further.
- Check store requirements: privacy labels, permissions explanations, screenshots.
Automation tools
| Tool | Platforms | Notes |
|---|---|---|
| Espresso | Android | Google's native UI testing framework; fast, written in Kotlin/Java |
| XCUITest | iOS | Apple's native UI testing framework; Swift |
| Appium | Android and iOS | Cross-platform, many languages; slower, flexible |
| Maestro | Android and iOS | Simple YAML flows; popular for quick end-to-end checks |
As with web, keep most checks below the UI (unit and API tests) and automate a few critical mobile flows end to end.
A banking app let users open an account in a long form. The last step asked for a photo of their ID card, using the camera.
Everything passed on the test team's new phones. After release, support received complaints: on some older Android phones, after taking the photo, users returned to an empty form and had to start over.
Taking the photo opened the camera app, which used a lot of memory. The OS killed the banking app in the background, and the app didn't save its state. The testers reproduced it in minutes with "Don't keep activities" enabled. After the fix, that setting and a low-memory device became part of every regression run.
Lesson: on mobile, "the user left the app and came back" is a test case. Your app doesn't control when the OS takes its memory away.
Do
Pick devices from analytics, explore on real devices, and include interruptions, permission denials and updates-with-data in every release test.
Don't
Test only on the newest flagship phone on fast office Wi-Fi. That's the device and network your users are least likely to have.
Check yourself
Your team releases a new version of a shopping app. What would you test specifically because it's an update, not a new install?
Show answer
Install the previous store version, create real state (logged-in user, items in cart, saved addresses, settings, offline data), then update to the new build. Check the user is still logged in, data is intact and migrated correctly, and nothing crashes on first launch. Also test updating from older versions users may still have, and test new permission prompts introduced in this version.
