
Written by: Chief Technology Officer
Dmitry ReznikUpdated: 13.11.2026
22 min read
A mobile app may work perfectly on a developer’s phone and still fail for real users. A different OS version, interrupted connection, denied permission, incoming call, or failed update can expose problems that never appear during standard functional checks.
The numbers show why narrow test coverage is risky:
Android accounted for 69.14% of the worldwide mobile operating system market in June 2026, while iOS held 30.79%, according to Statcounter Global Stats. Each platform also includes multiple OS versions, device generations, and screen configurations.
In Sauce Labs’ State of Mobile App Quality 2026, 49% of respondents said insufficient test coverage and late issue detection prevented them from achieving continuous mobile quality. Another 31% reported limited visibility into production and real-world performance.
Google Play classifies a user-perceived crash rate of 1.09% or higher as bad behavior. For Application Not Responding errors, the threshold is only 0.47%. Exceeding these limits can reduce an app’s visibility on Google Play.
Mobile app testing verifies how an application behaves across devices, operating systems, network conditions, and everyday usage scenarios. It covers more than buttons and business logic: testers also examine installation, resource consumption, security, interruptions, accessibility, and the app’s interaction with the device.
This guide explains the main types of mobile testing, provides a step-by-step process, and includes practical test cases you can adapt to your application.
What is mobile app testing?
Mobile app testing is the process of checking whether an application works as intended on its supported devices and operating systems. Its purpose is to find functional defects, usability problems, performance bottlenecks, compatibility issues, and security risks before they affect users.
Unlike a desktop or web application, a mobile app operates in an environment that can change from one moment to the next. The user may switch from Wi-Fi to cellular data, lock the screen, deny camera access, receive a phone call, rotate the device, or leave the app running in the background for several hours.
Hardware also varies. Two devices using the same operating system may have different screen sizes, memory limits, processors, sensors, or manufacturer-specific behavior. Testing must account for these differences without attempting to check every device on the market.
A complete mobile testing process usually covers:
Core user journeys and business rules
Device and operating system compatibility
Installation, updates, and uninstallation
Permissions and hardware integrations
Network changes and offline behavior
App performance and resource consumption
Data protection and session security
Background, foreground, and interruption handling
The objective is not to prove that the app has no defects. It is to collect enough evidence that the product works reliably under the conditions its users are likely to encounter.
Why is mobile app testing important?
A defect on a mobile device can block an entire customer journey. If an app loses a completed form after an incoming call, creates two orders after a repeated tap, or fails to preserve user data during an update, the technical problem quickly becomes a business problem.
Mobile quality teams are also under considerable delivery pressure. A 2025 Applause survey of more than 2,100 software development and testing professionals found that 36.8% considered the lack of time for sufficient pre-release testing very or extremely challenging. At the same time, only 14.7% of respondents limited testing and feedback collection to a single stage of the development lifecycle, down from 41.7% in the previous survey. The findings suggest that more teams are testing earlier instead of treating QA as a final release gate. Read the 2025 State of Digital Quality findings.
Several characteristics make mobile applications particularly sensitive to incomplete testing.
Devices and operating systems behave differently
An application may support multiple Android and iOS versions, screen dimensions, chipsets, and hardware configurations. Layouts that look correct on one screen can become clipped on another. A feature may work on the latest OS but fail after a permission or background-execution change on an older version.
Android’s global market share does not mean that testing one or two Android phones provides sufficient coverage. The platform runs across devices from many manufacturers, with different hardware, screen sizes, and system modifications.
Both Apple and Google recommend checking applications across the devices and operating system versions they support. Apple also advises testing release builds on physical devices because simulators do not reproduce every aspect of real hardware behavior. Apple’s release-build testing guidance provides more detail.
Mobile networks are unpredictable
Users open apps on fast office Wi-Fi, congested cellular networks, underground trains, and connections that disappear halfway through a transaction. Testing only under stable conditions leaves important questions unanswered:
What happens if the network disappears during payment?
Will a form preserve entered information?
Does the app retry a request without creating duplicates?
Can users understand whether an operation succeeded?
What happens when the device switches between Wi-Fi and cellular data?
These cases matter most for actions that modify data, such as ordering, booking, uploading, or transferring money.
Apps interact with the operating system
Mobile applications depend on cameras, microphones, GPS, biometric authentication, notifications, local storage, and other platform capabilities. Each integration introduces more states to test.
Users can deny or revoke permissions at any time. The operating system can suspend or terminate a background process. Another application can interrupt the current flow. Testing must verify that these events do not cause crashes, expose data, or leave the app in an inconsistent state.
Performance affects more than user experience
An application competes with other processes for memory, processor time, storage, network bandwidth, and battery. It can feel responsive during a short test yet slow down during a longer session or on less powerful hardware.
Startup performance also varies depending on whether the app is starting from scratch or returning from memory. Android distinguishes between cold, warm, and hot starts and recommends measuring both the first visible frame and the point at which the app becomes fully interactive. These metrics are explained in the official Android app startup documentation.
Stability can also influence discoverability. Google Play’s current Android vitals thresholds classify the following as bad behavior:
User-perceived crash rate
1.09%
8%
User-perceived ANR rate
0.47%
8%
Excessive partial wake locks
5%
—
A rate that appears small in a dashboard can therefore affect a meaningful number of users and reduce the app’s visibility on particular devices.
Security problems drive users away
Mobile apps routinely process credentials, personal details, payment information, health data, locations, and other sensitive records. Users expect this information to be protected even if they do not understand the underlying controls.
Appdome’s 2025 survey, covering mobile users across 12 countries, found that nearly 70% would stop using an app, delete it, or switch to a competitor if they discovered weak protection against fraud, identity theft, or privacy risks. View the 2025 Mobile Consumer Security Survey.
Security testing is therefore not only a compliance activity. Authentication failures, exposed data, and account takeover risks can directly affect retention and trust.
Updates can introduce risks that clean installations do not reveal
Existing users rarely install every version from scratch. They update an app while retaining accounts, preferences, cached content, downloads, and locally stored data.
A release may pass tests after a clean installation but fail when upgrading from a version published several months earlier. Installation and update testing helps identify database migration errors, lost settings, authentication problems, and damaged local data before deployment.
Mobile app testing vs. mobile web testing
Mobile apps and mobile websites share some test areas, but their operating environments differ.
Installation
Must be installed, updated, and removed
Opens in a browser
Device access
May use the camera, GPS, biometrics, contacts, or notifications
Hardware access is usually more limited
Platform dependency
Depends on Android or iOS behavior
Primarily depends on the browser
Background behavior
Must handle background, foreground, suspension, and termination
Usually controlled by the browser
Offline behavior
May store data and support offline workflows
Often more dependent on connectivity
Distribution
Released through app stores or enterprise channels
Deployed on a web server
Local data
Can maintain databases, cached files, and secure credentials
Usually relies on browser storage
Release process
May require store review and phased rollout
Can often be deployed immediately
A responsive website should still be checked on mobile browsers. However, it does not require the full set of installation, permission, interruption, and device-integration tests needed for an installed application.
Types of mobile app testing
Most applications require several complementary types of testing. Each one answers a different question about product quality.
Functional testing
Functional testing checks whether the app performs the actions described in its requirements.
Typical areas include:
Registration, login, logout, and account recovery
Navigation between screens
Search, filtering, and sorting
Data entry and form validation
Payments, orders, bookings, or subscriptions
Push notifications
Deep links
File uploads and downloads
API and third-party integrations
Error handling
A functional check should cover more than the expected path. For example, testing a payment means verifying successful transactions as well as declined cards, expired sessions, network interruptions, repeated taps, and delayed responses.
State also matters. The same deep link may behave differently for a logged-in user, a logged-out user, and a user who no longer has permission to view the linked content.
Usability testing
Usability testing evaluates whether people can complete tasks without confusion or unnecessary effort.
Testers examine:
Whether navigation is predictable
Whether buttons and other touch targets are easy to use
Whether text remains readable at supported sizes
Whether gestures behave consistently
Whether the keyboard covers fields or actions
Whether error messages explain how to recover
Whether progress indicators appear during longer operations
Whether entered information survives temporary interruptions
Whether layouts remain usable after an orientation change
A technically correct workflow can still be difficult to use. A registration form, for instance, may accept valid data but repeatedly clear completed fields after one validation error. Functional testing confirms that registration works; usability testing reveals why users may abandon it.
Performance testing
Mobile performance testing examines responsiveness, stability, and resource consumption.
Useful measurements include:
Cold, warm, and hot startup time
Time required to complete critical actions
Screen rendering and animation smoothness
CPU and memory usage
Battery consumption
Network traffic
App package size
Stability during long sessions
Behavior under weak or unstable connectivity
On-device performance and backend load are related but distinct. Simulating thousands of users can reveal whether APIs and infrastructure handle demand. It does not show whether one physical phone suffers from excessive memory usage, slow rendering, or battery drain.
Tests should therefore combine backend measurements with checks performed on representative devices.
Compatibility testing
Compatibility testing checks whether the application behaves consistently across its supported configurations.
Coverage can include:
Android and iOS versions
Phone and tablet layouts
Different screen sizes and resolutions
Device manufacturers
Processors and memory capacities
Light and dark modes
Display scaling and text size
Languages and regional formats
Foldable or other supported form factors
Testing every available device is rarely possible. The goal is to cover meaningful differences that could affect the product. Google’s core app quality guidelines recommend using a combination of emulators and representative hardware devices.
Security testing
Security testing looks for weaknesses that could expose accounts, personal information, payment data, or business systems.
It should cover:
Authentication and authorization
Session expiration and logout
Sensitive data stored on the device
Data transmitted between the app and backend
API access controls
Permissions
Logs and diagnostic information
Deep links and inter-app communication
Clipboard and screenshot behavior where relevant
Protection against tampering or reverse engineering when required
Logging out should do more than return the user to the login screen. Testers must check whether protected screens remain accessible through navigation history, deep links, cached content, or another device.
The OWASP Mobile Application Security Verification Standard provides structured controls for storage, cryptography, authentication, network communication, platform interaction, privacy, and resilience.
Installation and update testing
Installation testing covers the application’s lifecycle on the device.
Important scenarios include:
Clean installation
First launch
Installation on each supported OS version
Update from supported previous releases
Migration of local databases and settings
Interrupted installation or update
Installation with insufficient storage
Uninstallation
Reinstallation
Handling an unsupported OS version
Restoring the app from a device backup, where applicable
Update testing is especially important when the app stores drafts, downloaded content, preferences, or authentication data locally. The test should define which information must remain, which data should be migrated, and which sessions should expire for security reasons.
Depending on the product, the scope may also include accessibility, localization, recovery, and interruption testing.
How to test a mobile application step by step
The exact scope varies by product, but the following process provides a practical starting point.
Step 1: Identify critical user journeys
Begin with the actions that create the most value or carry the greatest risk.
For an ecommerce app, these might include registration, search, checkout, payment, and order tracking. For a healthcare product, the critical flows could be appointment booking, access to test results, messaging, and medication reminders.
Document the starting state, required data, expected result, and potential failure points for each journey. This prevents testing from becoming a collection of disconnected screen checks.
Step 2: Define the testing scope
Record the platforms and configurations included in the release:
Supported Android and iOS versions
Phone, tablet, or other form factors
Features changed in the current build
Integrations affected by those changes
Supported languages and regions
Relevant user roles
Features that will not be tested and why
The purpose of this step is to make the release scope explicit, not to create a complete organizational testing strategy.
Step 3: Prepare the environment
Before execution, confirm that testers have:
The correct application build
Access to physical devices or emulators
Test accounts for relevant user roles
Suitable test data
Access to the required backend environment
Valid test payment methods or sandbox integrations
Logs, crash reports, or other diagnostic information
A place to record defects and results
Environment problems can look like product defects. Label builds clearly and record the tested app version, OS version, device model, account, and environment with every issue.
Step 4: Test installation and updates
Install the application on a clean device and verify the first launch. Then test updates from supported older versions.
Pay attention to:
Authentication state
Local databases
Saved drafts
Preferences
Downloaded content
Notification settings
Previously granted or denied permissions
Also test removal and reinstallation. Define whether data should disappear, return from cloud storage, or remain in a platform-managed backup.
Step 5: Run smoke tests
A smoke test determines whether the build is stable enough for deeper testing.
Verify that the app:
Installs and opens
Does not crash immediately
Connects to the expected environment
Allows a user to sign in
Loads its main screens
Completes at least one critical workflow
If basic operations fail, extensive testing of that build may provide little value until the blocking problem is fixed.
Step 6: Test core functionality
Execute the main user journeys and related negative cases. Check field validation, business rules, navigation, API responses, error handling, and data consistency.
Do not test each screen in isolation. Follow information across the system. If a user changes an address in the app, confirm that the change appears in the account, affects the next order correctly, and remains after the app is restarted.
Step 7: Reproduce mobile-specific conditions
Repeat important workflows while changing the device state.
Useful scenarios include:
Switching from Wi-Fi to cellular data
Losing and restoring connectivity
Enabling airplane mode
Receiving a call or notification
Sending the app to the background
Locking and unlocking the screen
Rotating the device
Denying or revoking a permission
Enabling low-power mode
Running low on storage
Returning after the operating system has terminated the process
Google includes interruptions, network changes, sleep, lock, and app switching in its core Android quality tests. These checks often reveal state-management defects that normal functional scripts miss.
Step 8: Evaluate usability and accessibility
Complete critical journeys from a user’s perspective. Look for unclear labels, small touch targets, hidden controls, unexpected gestures, and error messages that do not explain the next step.
Accessibility affects a substantial part of the potential audience. The World Health Organization estimates that 1.3 billion people – approximately 16% of the global population – experience a significant disability. See the WHO disability overview.
Test supported accessibility features, including:
Screen readers
Text scaling
Color contrast
Alternative labels
Focus order
External keyboards, when relevant
Interfaces that do not rely on color alone
Automated checks are useful but incomplete. Applause’s 2025 accessibility report estimates that automated accessibility tools identify only 20-40% of issues. The same survey found that 47% of responding organizations were already aware of barriers affecting assistive-technology users on their websites or apps.
Accessibility testing should therefore include human evaluation on real screens rather than relying only on scanners or design files.
Step 9: Measure performance
Measure startup and response times under repeatable conditions. Observe CPU, memory, battery, network use, and rendering during typical and extended sessions.
Compare results across at least one higher-performance and one lower-performance supported device. A build that feels fast on a recent flagship phone may behave differently on hardware with less memory or a slower processor.
Investigate changes against an agreed baseline rather than relying only on whether the app “feels slow.” Monitor production metrics by app version and device model as well: aggregate results can hide a serious problem affecting one configuration.
Step 10: Run security checks
Verify authentication, authorization, storage, communication, and session behavior.
At minimum, check that:
Users cannot access another user’s data
Protected content is unavailable after logout
Sensitive values do not appear in logs
Credentials and tokens are stored appropriately
API requests enforce authorization on the server
Invalid or manipulated deep links fail safely
Permissions are limited to actual product needs
Session expiration works as designed
Products handling payments, healthcare information, financial data, or other sensitive records may require a dedicated security assessment.
Step 11: Complete regression and record release risks
After fixes are delivered, retest each defect in the environment where it occurred. Then run regression tests around the changed functionality and connected features.
The final result should state:
What was tested
Which devices and OS versions were covered
Which tests passed or failed
Which defects remain open
Which areas were not tested
What risks are being accepted for release
A “passed” label without this context can create false confidence.
Mobile app test case examples
The following examples can be adapted to different applications.
Installation
Install the app on a supported OS version
Installation completes and the app opens without corrupted data
First launch
Open the app immediately after installation
The correct onboarding or initial screen appears
Update
Update while the user is logged in and has locally stored data
Supported data is migrated correctly and the account remains in the expected state
Login
Submit invalid credentials
A clear error appears without exposing sensitive information
Session
Reopen the app after the session has expired
The user is asked to authenticate before protected content appears
Permissions
Deny camera or location access
The app explains the limitation and continues without crashing
Permissions
Revoke an existing permission in device settings
The app detects the change and requests access only when the feature needs it
Network
Switch from Wi-Fi to cellular data during an action
The operation continues or fails with a recoverable message
Offline behavior
Submit a form without connectivity
Entered data is preserved or the user receives clear recovery instructions
Interruption
Receive a call while completing a form
The app resumes in a safe state without losing entered information
Background state
Leave the app and return after several minutes
The appropriate screen and data are restored
Process termination
Return after the OS terminates the background process
The app restores a valid state rather than showing broken or stale content
Push notification
Open a notification while logged out
Authentication is required before protected content is displayed
Deep link
Open an invalid or expired link
The app shows a safe fallback instead of crashing or displaying a blank screen
Payment
Tap the payment button repeatedly
Only one transaction is created
Orientation
Rotate the device during an active workflow
The layout adapts without losing information
Low storage
Start an update without enough available storage
A clear error appears and existing app data remains intact
Logout
Log out and reopen the app
Protected information is no longer accessible
Accessibility
Navigate a key workflow with a screen reader
Controls have meaningful labels and follow a logical focus order
Performance
Repeatedly use a critical flow during an extended session
Memory and response times remain within defined limits
Specific inputs, preconditions, and expected results should be added before these examples become executable test cases.
Mobile app testing checklist before release
Before approving a build, confirm that:
Critical user journeys have passed.
The app has been tested on supported OS versions.
Representative screen sizes and device types have been covered.
Clean installation, update, uninstallation, and reinstallation have been checked.
Permissions are requested at the appropriate time and handled correctly.
Network loss, reconnection, and offline behavior have been tested.
Interruptions do not cause crashes or data loss.
Push notifications and deep links behave correctly.
Performance and resource consumption remain acceptable.
Sensitive information is protected.
Fixed defects have been retested.
Relevant regression tests have passed.
Untested areas and known release risks have been documented.
Test the conditions users will actually encounter
A mobile application is not ready simply because its primary features work on one device. Release confidence comes from checking how those features behave during updates, interruptions, permission changes, unstable connections, and transitions between device states.
Start with the journeys users cannot afford to lose, then test the conditions most likely to disrupt them. That approach produces clearer results than a long list of disconnected checks – and makes the remaining release risks easier to see.
Need help validating an application across devices, operating systems, network conditions, and release scenarios? Explore DeviQA’s mobile app testing services.
Steady QA for every growth stage
Frequently asked questions
What is mobile app testing?
Mobile app testing checks whether an application functions correctly across its supported devices, operating systems, and usage conditions. It covers functionality, usability, compatibility, performance, security, installation, updates, permissions, network changes, and interactions with device features.
Why is mobile application testing important?
Mobile applications operate under changing conditions and on hardware with different capabilities. Testing helps prevent crashes, lost data, broken layouts, duplicate transactions, security failures, and update problems that may not appear in a development environment.
What are the main types of mobile app testing?
The main types include functional, usability, performance, compatibility, security, and installation testing. Depending on the application, the scope may also include accessibility, localization, recovery, interruption, and backend load testing.
How do you test a mobile app step by step?
Start by identifying critical user journeys and supported configurations. Prepare the environment, test installation and updates, run smoke and functional checks, reproduce mobile-specific conditions, evaluate usability, measure performance, check security, and finish with defect retesting and regression testing.
What test cases are essential for a mobile application?
Every app should cover installation, login, permissions, network changes, interruptions, background behavior, supported screens, error handling, updates, logout, and its most important business flows. Payment, location, notification, or media applications will require additional product-specific cases.
Can mobile app testing be automated?
Yes. Stable and repeatable checks such as smoke tests, regression scenarios, API tests, and some UI flows are suitable for automation. Exploratory, usability, accessibility, and hardware-dependent checks still benefit from human evaluation. The appropriate balance depends on the product and release process.
Should mobile apps be tested on real devices or emulators?
Both are useful. Emulators provide fast access to different configurations, while physical devices reveal hardware, performance, battery, sensor, and release-build behavior that simulations may not reproduce. Device selection and coverage are explored further in this guide to mobile app testing best practices.

About the author
Chief Technology Officer
Dmitry Reznik is the Chief Technology Officer and co-founder at DeviQA, bringing deep technical expertise across software architecture, implementation, and long-term system operation.