Back to all posts
App Testing7 min read·November 15, 2026

How to Test an Android App on Low-End Phones

TB
ThynkBlox Apps Team
App Engineering

To test an Android app on low-end devices, pick a small set of test phones based on your own users: one per memory tier, a spread of Android versions and the screen sizes people actually use. Then run the same short checklist on each phone: cold start, scrolling long lists, camera use, low storage, the system closing the app in the background, and slow networks. Write down what passed, what failed and how each failure showed up, so that a fix can be checked against the same conditions.

Why do low-end phones need their own testing?

Most development and review happens on recent, capable phones. A phone with little memory, a slower processor and limited free storage behaves differently. It takes longer to start apps, drops frames during scrolling, and closes background apps sooner to free memory.

None of these problems show up as clear errors on a fast phone. A screen that loads instantly in the office can take several seconds on a budget device, and an app that keeps its state on a flagship phone can lose a half-finished form when the system reclaims memory. If part of your audience uses lower-end hardware, those users see a different app from the one your team tests.

Low-end testing does not replace general release testing. It is one layer within the broader process in how to test an Android app before release.

How do you choose a small device matrix?

Start from your own user base rather than general assumptions. If the app is live, your analytics and the device reports in your store console show which memory tiers, Android versions and screen sizes your users have. Before launch, use what you know about your target audience and update the matrix once real data arrives.

Keep the matrix small enough to run on every release. Three to five devices is usually enough to cover the meaningful differences. Choose them along three axes:

AxisWhat to coverWhy it matters
Memory tierThe lowest tier with meaningful usage, plus one middle tierLow memory causes background kills, slow starts and image loading failures
Android versionThe oldest version you support, the most common version among your users, and a recent onePermissions, background limits and storage access differ between versions
Screen size and densityThe smallest screen in common use and one large screenSmall screens expose cut-off buttons, overlapping text and cramped forms

One phone can cover more than one axis. A low-memory phone running your oldest supported version on a small screen is often the most useful device in the set. If you are considering raising your minimum version, see deciding when to drop old Android version support.

Real devices are best for memory and performance checks, because emulators run on desktop hardware and hide much of the slowness. Emulators are still useful for checking layouts across screen sizes and Android versions.

What should the low-end testing checklist include?

Run each check on every device in the matrix, starting from a clean install and repeating with an install that already has realistic data.

CheckHow to run itPass note
Cold startForce-stop the app, then open it from the launcherFirst useful screen appears without a blank or frozen period that a user would notice; no "app not responding" prompt
Scrolling listsScroll the longest lists quickly, with images loadedScrolling stays smooth enough to read; images fill in without blocking scrolling; no crash after long scrolling
CameraTake a photo or scan inside the app, then return to the previous screenCaptured image is kept; the screen you return to still holds entered data
Low storageFill the phone until little free space remains, then download, cache or saveApp shows a clear message instead of failing silently or crashing
Background killFill in a form, switch to other heavy apps, then returnApp restores the screen and entered data, or explains clearly what was lost
Slow networkUse a throttled or weak connection for sign-in, loading and submittingLoading states appear, timeouts are handled, and nothing is submitted twice

For deeper network testing, follow testing a mobile app on slow networks. If cold start fails, diagnosing slow mobile app startup explains how to find what the app does before its first screen.

To test background kills reliably, turn on "Don't keep activities" in the phone's Developer options, which destroys each screen as soon as the user leaves it, or lower the "Background process limit" setting. This approximates what a low-memory phone does on its own, without waiting for it to happen.

What does an issue found on a low-memory device look like?

The following example is illustrative. The app and details are invented to show the process.

A field-service app lets technicians fill in a job report, attach a photo of the completed work, and submit. On the team's own phones, the flow works every time.

On the lowest-memory phone in the matrix, a tester fills in six fields, taps "Add photo" and takes a picture. When the camera closes, the app returns to a blank job report. The photo is not attached, and the six fields are empty.

What happened. While the system camera app was open, the phone ran short of memory and closed the field-service app in the background. When the camera returned, Android recreated the screen, but the app had kept the form data only in memory and had not saved the location of the photo file. Both were lost.

How the team confirmed it. They turned on "don't keep activities" on a fast phone and repeated the flow. The same blank form appeared, which showed the cause was the screen being destroyed and recreated rather than a camera fault.

The fix. The developers saved the form fields and the pending photo location so they survived recreation, and restored them when the screen came back. The approach is described in restoring mobile app progress after process death.

The retest. The tester repeated the flow on the low-memory phone and on the fast phone with "don't keep activities" turned on. The pass note recorded that the fields and photo were restored on both. The check was added to the regular release checklist.

How do you record results so they stay useful?

Keep one row per check per device. Record the device's memory tier, Android version, app version, whether the install was clean or had existing data, and the result. For failures, add the steps, what the user would see and a screen recording where possible.

Short, specific pass notes are more useful than "OK". "Cold start reaches home screen; brief blank screen before splash" tells the next tester what to watch for. Comparing notes between releases also shows when something is getting slower before it becomes a failure.

What common mistakes should you avoid?

Choosing devices from habit. A matrix built from whatever phones the team owns may miss the tier your users actually have. Base it on your user data.

Testing only with fresh installs. Long lists, large caches and saved drafts make problems appear that an empty account hides.

Relying on emulators for performance. They are useful for layouts and versions, but they rarely show real slowness or memory pressure.

Treating a background kill as a rare edge case. On low-memory phones it is ordinary behaviour, especially around the camera, file pickers and payment screens.

Fixing without retesting on the same device. Confirm the fix under the conditions that caused the failure.

When does this not apply?

If your app is only for a managed fleet of known, capable devices, such as company-issued phones, test on that hardware instead of building a wide matrix. The checklist still applies, but the device choice comes from the fleet. If the app is still a prototype checking demand, keep testing light until the core flow is settled, and run the full matrix before public release.

What questions do founders often ask?

How many low-end phones does a small team need?

Often two or three are enough: one low-memory phone on your oldest supported Android version, one mid-range phone on a common version, and one with a small screen. Let your own user data decide the details, and adjust the set when your audience changes.

Can a cloud device service replace physical phones?

It can extend coverage across Android versions and screen sizes, and it helps with layout checks. Keep at least one physical low-memory phone for camera, storage and background-kill checks, because those depend on real hardware conditions that remote sessions may not reproduce faithfully.

How often should the low-end checklist be run?

Run it before each release that changes startup, lists, media, storage or network handling, and at least once before every major release. A quick pass on the lowest-tier phone catches most regressions. Keep the results with your release notes so changes over time are easy to compare.

Who should run these tests if we hire an agency?

Agree in your contract or brief that the agency tests on a named device matrix based on your users, and shares pass notes for each release. Ask to see the results. Our services page explains how we approach testing during a build.

Ready when you are

Planning an app of your own?

Tell us where your project is today. We will help you work out the scope before you commit to a budget.