Mobile app performance testing checks how quickly and smoothly an app starts, draws its screens and responds on real phones and real networks, how much CPU, memory and battery it consumes along the way, and how its backend copes when many people use it at once. In practice it pays off most as a check you repeat on every build, run against the handful of journeys your users care about, rather than a one-off audit before a big launch. This guide covers what to measure in each layer, a seven-step routine for real devices, and which tools suit each part of the job.
What is mobile app performance testing?
Mobile app performance testing is the practice of measuring speed, smoothness and resource use for an Android or iOS app under conditions that resemble how your users actually run it. The work splits into three layers, and each one needs its own method.
- On-device behaviour. Startup time, frame rendering, CPU, memory and battery, all measured on the handset while someone (or an automated test) moves through the app.
- Network and API behaviour. How many requests a screen fires, how large the responses are, how fast data arrives, and what the app does when the connection drops or switches.
- Backend capacity. How your servers respond when thousands of sessions arrive together. Load, stress and endurance runs live here, and our guide to load testing tools for mobile apps goes deeper on that layer.
Treating these as one job is where most teams lose time. A slow search screen can come from a heavy image decoder on the phone, an oversized API response, or a database struggling at peak hour, and each cause shows up in a different place.
To keep this concrete, we will follow one fictional app throughout: a food delivery app whose search-to-checkout flow started to feel sluggish on mid-range Android phones right after a release that added restaurant photos to the search results.
What should you measure in mobile app performance testing?
Measure the signals that map to something a user can feel, then attach a budget to each one. Here is what each group means in plain terms.
Startup time. Android Developers splits app startup into cold, warm and hot starts. A cold start launches the process from nothing, so it is the slowest case and the one to watch on low-end phones. Track time to first frame and time until the screen is fully usable.
Frame rendering. To hit 60 frames per second, each frame has roughly 16 ms to render. Android's guidance on slow rendering treats frames over 16 ms as slow, frames over 700 ms as frozen, and reports an Application Not Responding (ANR) error when the main thread stays blocked for five seconds. Users describe all of this as "jank" or "the app froze".
CPU. Separate the app's own CPU share from system-wide CPU. A spike in app CPU while a list scrolls points at your code; high system CPU with modest app usage may point at the device or other processes.
Memory. Watch peak memory and, just as importantly, growth across a session. Memory that climbs screen after screen and never falls back hints at a leak or an unbounded cache.
Battery drain. Record drain over a fixed journey so you can compare builds fairly. Background work, location polling and wake locks tend to show up here first.
Network. Count requests per screen, measure payload size and throughput, and check behaviour when the phone goes offline or hops between Wi-Fi and mobile data.
Backend response under load. Measure response times and error rates while a load tool simulates many concurrent users. This is the only row where the phone itself is not the subject.
In the food delivery app, the device layer is where the photo release would show its cost: memory climbs on the search results screen as thumbnails decode, and janky frames rise while the user scrolls. The network layer would likely show heavier payloads per search. The backend layer might look perfectly normal, which is useful to know because it rules out a server fix.
| Metric |
What it tells you |
Where to read it |
Published reference point (source) |
| Startup time (cold, warm, hot) |
How long a user waits before the first usable screen |
Android Studio, Macrobenchmark, Xcode Instruments, device metrics during test runs |
No single number; track each start type against your last release (Android Developers) |
| Slow frames |
Whether scrolling and animations stutter on a given screen |
Frame timing in profilers or device metrics |
Over 16 ms per frame at 60 fps (Android Developers) |
| Frozen frames |
Moments where the UI visibly locks up |
Frame timing in profilers or device metrics |
Over 700 ms (Android Developers) |
| ANRs (Android) |
Main-thread blocks long enough for Android to warn the user |
Android vitals, crash and ANR reports |
Main thread blocked for 5 seconds (Android Developers) |
| CPU (app and system) |
Whether your code or the device is doing the heavy lifting on a screen |
Profilers, device clouds, device metrics |
Set from your last release |
| Memory (peak and growth) |
Leaks, oversized images and caches that never shrink |
Memory profiler, device metrics |
Set from your last release |
| Battery drain |
Cost of a fixed journey to the user's charge |
Energy profiling, device metrics |
Set from your last release |
| Requests, payload and throughput |
How chatty and heavy each screen is over the network |
Network inspector, device metrics, proxy logs |
Set from your last release |
| Backend response under load |
Whether servers keep up when many sessions arrive together |
Load tool reports (JMeter, k6) |
Set from your service targets |
How do you do mobile app performance testing on real devices?
Run a short, repeatable routine on real handsets for every build, and compare each result with the release before it. These seven steps cover most teams.
- Pick three to five journeys that earn or keep users. For the food delivery app, that means app launch, restaurant search, add to cart and checkout. Leave settings screens for later.
- Set budgets before you measure. Use the platform reference points in the table above where they exist, and your last shipped release as the baseline everywhere else. A budget turns "feels slower" into a pass or a fail.
- Choose real devices across low, mid and high tiers your users actually own. Your analytics tell you which models matter. Running the same journeys on several handsets at once keeps run time manageable, and our write-up on running the same flows on several devices in parallel shows how teams organise that.
- Reset to a known state and repeat each run. Clear app data, log in with the same test account and run each journey a few times, so one noisy run never decides the outcome.
- Capture on-device metrics during the functional runs you already automate. The tests that confirm search and checkout work can collect CPU, memory, frames and battery in the same pass, step by step. If you already re-run journeys each build with your regression testing tools, this adds measurement without adding a separate suite.
- Check network states, and keep backend load as its own run. Switch the phone offline mid-journey, move between Wi-Fi and mobile data, and confirm the app recovers. Run load tests against the backend separately so phone-side numbers stay clean.
- Compare against the last release and feed the result into the release gate. Put performance next to functional results in the same go or no-go decision, inside your mobile CI/CD testing flow if you have one. Our release-stage checklist shows where this fits among the other pre-release checks.
In the food delivery case, step 5 is where the photo problem surfaces: the search results step on a mid-tier phone breaches the memory budget and shows a jump in janky frames, while the same step on a flagship stays within budget. That single comparison tells the team the fix is image sizing or caching on the client, not more servers.
Which mobile app performance testing tools fit each layer?
No single tool covers every layer, so pick one per job and make sure the results land in the same release conversation. Grouped by job, the common options look like this.
Developer profilers. Android Studio's profilers inspect CPU, memory, power and network on profileable or debuggable builds. Jetpack Macrobenchmark measures larger interactions such as startup and scrolling and can run in CI. Perfetto is an open-source tracing suite for digging into system-level performance on Android. iOS engineers use Xcode Instruments, which Apple documents in its guide to improving your app's performance.
Real-device performance on device clouds. BrowserStack says its App Performance metrics include slow and frozen frames, ANRs, CPU, memory, battery, network traffic and app startup time, collected during App Automate sessions. TestGrid says its performance testing tracks CPU, memory, battery, network activity and UI response times on real Android and iOS devices, with network profiles from 2G to 5G.
Backend load. Apache JMeter is an Apache open-source project for load testing, and Grafana describes k6 as an open-source, developer-friendly performance testing tool. Both simulate many virtual users against your APIs.
Production monitoring. Firebase Performance Monitoring automatically collects app start, screen rendering and HTTP/S request data from real users on Android and Apple platforms, which shows whether lab results match the field.
Performance data during functional runs. QApilot captures Device Metrics on Android while your functional test plans execute, covered in its own section below.
| Tool |
Layer |
Platforms (per vendor) |
What it measures (per vendor) |
Open source or cost model |
Source |
| Android Studio Profiler |
Developer profiling |
Android |
CPU, memory, power, network on profileable builds |
Ships free with Android Studio |
Android Developers |
| Perfetto |
Developer tracing |
Android (plus Linux and Chrome traces) |
System and app traces for performance issues |
Open source |
perfetto.dev |
| Jetpack Macrobenchmark |
Developer benchmarking |
Android |
Startup, scrolling and animation timing; runs in CI |
Free Jetpack library |
Android Developers |
| Xcode Instruments |
Developer profiling |
iOS and other Apple platforms |
App performance profiling inside Xcode |
Ships free with Xcode |
Apple |
| BrowserStack App Performance |
Real devices in a cloud |
Android and iOS (detailed version on specific plans) |
Frames, ANRs, CPU, memory, battery, network, startup |
Paid plans |
BrowserStack |
| TestGrid |
Real devices in a cloud |
Android and iOS |
CPU, memory, battery, network, UI response times; runs JMeter plans |
Paid plans |
TestGrid |
| Apache JMeter |
Backend load |
Platform independent (Java) |
Server response and throughput under simulated users |
Open source |
jmeter.apache.org |
| Grafana k6 |
Backend load |
Platform independent |
Load and performance of APIs and services |
Open source |
Grafana |
| Firebase Performance Monitoring |
Production monitoring |
Android and Apple platforms |
App start, screen rendering, HTTP/S requests from real users |
Not stated on the cited page |
Firebase |
| QApilot Device Metrics |
Metrics during functional runs |
Android only |
CPU, memory, battery, network throughput, janky frames per test step |
Commercial product |
QApilot docs |
If budget matters more than coverage, the open-source route is workable: Perfetto, Apache JMeter and Grafana k6 all describe themselves as open source, while Android Studio's profilers and Xcode Instruments come bundled with the free IDEs. That combination covers developer profiling and backend load at no licence cost, though you will still need real handsets for the on-device layer. If you want a longer catalogue with more vendors, see our mobile performance testing tools list.
Real devices, emulators or a device cloud?
Use emulators and simulators for early functional checks, but judge performance budgets on real hardware. CPU scheduling, memory pressure, thermal throttling, battery behaviour and frame timing on a laptop-hosted emulator rarely match what a three-year-old mid-range phone does in someone's hand, so numbers from an emulator make a poor release signal.
A device cloud gives you a wide range of models and parallel capacity without buying phones, which suits teams whose users spread across many brands and OS versions. A private device lab or farm suits teams that need fixed hardware, specific carrier setups or data that must stay on premises. Many teams mix the two: a small in-house set of the most common models for daily runs, and a cloud for broader sweeps before a major release.
The photo grid slowdown makes the point plainly: it only appeared on mid-tier hardware, so a lab made only of emulators or flagship phones would have shipped it.
How QApilot captures device metrics during Android functional runs
QApilot records device performance while your existing functional test plans run on Android, so performance and correctness come from the same execution. The feature is documented as Device Metrics for Android and is currently Android only.
You switch it on per test plan with the App Performance Analysis toggle in the execution settings. From then on, every execution report for that plan includes a Device Metrics tab with summary cards for peak system CPU, peak memory, battery drain, peak network throughput (with received and transmitted totals) and peak janky frames, each alongside a session average.
Benchmarks set the thresholds that trigger alerts, and you can tune them to your own targets. Breaches appear in an alert summary grouped as Critical, Warning or Info; one documented example alert fires when app startup to a fully drawn state takes longer than 3 seconds. Time-series charts plot CPU, memory, janky frames, battery and network on a shared timeline, and a step details panel shows the device screenshot at the selected moment, so a spike maps to the test step that caused it.
In the food delivery example, the memory and janky frame spike would line up with the search results step in the report, with the screenshot showing the photo grid on screen.
Runs can use local devices, supported cloud device providers or your own private device farm, and plans can run once, daily, or from CI through the downloaded script. QApilot does not run load tests; it works alongside device clouds and backend load tools such as JMeter.
Mobile app performance testing FAQ
How do you do mobile app performance testing?
Start with the few journeys that matter most, such as launch, search and checkout, and give each a budget for startup, frames, CPU, memory, battery and network use. Run those journeys on real phones from several price tiers, repeat each run, and compare with your previous release. Load test the backend on its own with a tool like JMeter or k6, then bring both sets of results to the release decision.
What are the best mobile app performance testing tools?
The right answer depends on the layer. Engineers usually profile with Android Studio Profiler, Perfetto or Xcode Instruments. QA teams check real-device behaviour on clouds like BrowserStack or TestGrid, or capture Android Device Metrics during functional runs with QApilot. Backend teams use JMeter or k6 for load, and Firebase Performance Monitoring watches what happens in production.
Is load testing the same as mobile app performance testing?
No. Load testing covers one slice: whether your servers hold up when many users arrive at once. Mobile app performance testing also covers what happens on the phone, such as slow cold starts, frozen frames, CPU spikes, memory growth and battery drain, none of which a load tool sees.
Measure the journeys, every build
Choose the journeys that matter, give each one a budget, measure every layer with a tool built for it, and keep the numbers next to your functional results when you decide whether a build ships. Done each release, this catches slowdowns like the food delivery photo grid while the fix is still one change old.