Back to all posts
Testing7 min read·November 8, 2026

How to Test a Mobile App on Slow and Unstable Networks

TB
ThynkBlox Apps Team
App Engineering

To test a mobile app on slow and unstable networks, run your most important flows under throttled and dropping connections. Then check five behaviours: how screens load, how requests retry, how timeouts surface, how uploads recover and how the app handles repeated taps. Write the network conditions and expected results down as a test matrix so every release is checked the same way. A flow passes when the user always knows what is happening, no data is lost or duplicated, and the app recovers without a restart.

Why does a fast office connection hide real problems?

Most development and review happens on stable Wi-Fi, where requests finish before anyone sees a loading state or a timeout. Real users open apps in lifts, on trains, in basements and in crowded places where the connection is slow, inconsistent or gone.

Bugs found on bad connections tend to be serious. A spinner that never stops, a payment submitted twice or a form that clears itself after an error can all lead to support requests and poor reviews. These behaviours are hard to spot by reading code, so you need to test for them on purpose.

Which network conditions should you test?

You do not need to cover every possible connection. Choose a small set of named profiles and use them consistently.

ProfileWhat it simulatesWhat it tends to reveal
NormalStable, reasonably fast connectionBaseline behaviour to compare against
SlowLow bandwidth and high latencyMissing loading states, blocked screens, early timeouts
LossySome requests dropped or delayedRetry gaps, inconsistent data, partial screens
Drop mid-requestConnection lost after a request startsUnclear results, duplicates, stuck states
OfflineNo connection at allError messages, cached content, queued actions
FlappingConnection repeatedly lost and restoredRetry storms, race conditions, repeated prompts
Network switchMoving between Wi-Fi and mobile dataDropped sessions, restarted uploads

Set the exact bandwidth and latency values for each profile within your team and keep them the same between releases. The values below are illustrative only: a "Slow" profile might use a few hundred kilobits per second with a delay of around one second per round trip.

Simulate these conditions with the network throttling in emulators and developer tools, a proxy that can add delay and drop requests, or a physical device with Wi-Fi and mobile data switched on and off by hand. Check the main flows on at least one real device as well, because emulators do not reproduce every radio or operating system behaviour.

What should you check for loading?

On the Slow profile, open each main screen and watch the first few seconds.

  • A loading indicator or placeholder appears quickly, before the content arrives.
  • The screen stays usable where possible. Back navigation still works.
  • Partial content does not shift or jump when the rest arrives.
  • Cached content, if the app has any, is shown and clearly marked as possibly out of date.
  • Images load progressively or show a placeholder instead of leaving blank gaps.

Our guide to designing loading, empty and error states covers how these screens should look. Slow-network testing checks that they actually appear.

How should retries and timeouts behave?

Each request needs a timeout, and each timeout needs a visible outcome. On the Lossy and Drop profiles, confirm that:

  • No request waits forever. After the agreed limit, the user sees a clear message and a way to try again.
  • Automatic retries, if used, are limited in number and spaced out, so the app does not flood the server when the connection returns.
  • Retrying a read, such as loading a list, is harmless.
  • Retrying a write, such as saving or paying, cannot create a second record. This needs a server-side safeguard, not just a disabled button.
  • Error messages say what happened and what to do next, without technical codes.

If your app depends on an existing API, confirm that it can recognise repeated requests before you test. The checks in whether your existing backend is ready for a mobile app help here.

How do you test partial uploads?

Uploads take the longest, so they are the most likely to be interrupted. Start a photo or file upload on the Slow profile, then cut the connection at different points: near the start, about halfway and just before it finishes.

Check that:

  • Progress is shown and does not jump backwards without explanation.
  • The user is told the upload paused or failed, not left with a frozen progress bar.
  • The upload resumes or restarts on its own, or the user can retry with one tap, without choosing the file again.
  • The server never keeps a half-written file as if it were complete.
  • An interruption just before completion does not produce two copies after a retry.
  • Leaving the screen or backgrounding the app during an upload behaves as designed.

For the design side of this, see how to build reliable mobile app photo uploads and Android background tasks and sync.

How do you test duplicate taps?

On a slow connection, users tap a button, see nothing happen and tap again. Test every action that creates, changes or charges something.

  1. Switch to the Slow profile.
  2. Tap the submit button several times quickly.
  3. Tap once, wait, then tap again before the response arrives.
  4. Tap once, drop the connection, restore it and tap again.
  5. Check the server data as well as the screen.

The pass condition is exactly one order, message, booking or charge for each intended action. The button should show it is busy after the first tap. Preventing duplicate submissions in a mobile app explains the client and server measures that make this hold.

What does a complete test matrix look like?

Combine your key flows with the network profiles. The worked example below is illustrative, for a typical app with sign-in, a feed, a photo upload and a checkout.

FlowSlowLossyDrop mid-requestOfflineFlapping
Sign inLoading shown, no timeout before limitRetry works, no lockoutClear message, can retryClear offline messageNo repeated prompts
Load feedPlaceholders, then contentNo duplicated or missing itemsPartial list handledCached feed or empty stateRefreshes once when back online
Photo uploadProgress visibleResumes or retriesNo half file kept, no duplicateQueued or clearly blockedNo duplicate copies
CheckoutButton busy after first tapOne charge onlyResult confirmed after reconnectBlocked with explanationOne charge only

Record each cell as pass, fail or not applicable, with the device, app version and date of the run. Keep failures as reproducible steps so a developer can follow them.

What are good pass criteria?

Agree the criteria before testing so results are not a matter of opinion. A practical set:

  • Feedback: the user sees a loading, success or error state for every action within a short agreed time.
  • No dead ends: every error offers a next step, such as retry, go back or continue offline.
  • No data loss: text the user entered survives a failed request.
  • No duplicates: each intended action produces exactly one result on the server.
  • Recovery: when the connection returns, the app continues without needing to be closed and reopened.
  • No crashes: no crash or freeze under any profile. Feed any that appear into your process for prioritising crash reports.

What common mistakes should you avoid?

Testing only offline. Being fully offline is easy to detect. Slow and half-working connections cause most of the confusing bugs.

Relying on a disabled button. It helps, but a retried request after a dropped response can still duplicate a write unless the server checks for it.

Checking only the screen. Look at server records too. A screen can show one order while the database holds two.

Changing profiles between releases. If the numbers change, you cannot compare results.

Leaving it until the end. Network handling affects API design. Find gaps early, while changing it is still cheap.

When does this not apply?

Apps that work fully offline with no server, such as a local calculator, only need basic checks. Apps that sync data while offline need deeper conflict testing as well, covered in planning offline data sync.

What questions do founders often ask?

Do we need special tools to test slow networks?

Not at first. Emulator throttling, a proxy that can delay or drop requests and a real phone with flight mode cover most cases. Add dedicated tooling if you run these tests often.

How often should we run the matrix?

Run it before each release that touches networking, uploads, payments or sign-in, and do a lighter pass on other releases. It fits alongside the wider checks in how to test an Android app before release.

Can automated tests cover this?

Partly. Automated tests can simulate timeouts, errors and repeated requests reliably. Manual testing on real devices is still useful for judging whether the experience makes sense to a user.

Who should own slow-network testing?

The person responsible for release quality should own the matrix, with developers fixing failures. If you work with a studio, ask how it handles this. Our services page describes how we approach testing.

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.