Dmitry Reznik

Written by: Chief Technology Officer

Dmitry Reznik

Updated: 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:

Android quality metric
Overall threshold
Per-device threshold

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.

Area
Native or hybrid mobile app
Mobile website

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.

Area
Test case
Expected result

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.

Dmitry Reznik

About the author

Dmitry Reznik

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.