Simulating Slow Networks on Android – A Complete Guide

Why you need to simulate a slow network

When you develop or troubleshoot an Android app, the most common real‑world complaint is that the app feels sluggish on a 3G or edge connection. Testing only on a fast Wi‑Fi network hides latency‑related bugs, oversized payloads, and UI freezes caused by long‑running network calls. By deliberately throttling the device’s network, you can observe how your code behaves under the exact conditions your users experience, and you can adjust caching, retry logic, and UI feedback accordingly.

Before you start

• Device requirements: Android 6.0 (Marshmallow) or newer. Most modern phones support the built‑in network‑speed simulator, but some OEM skins hide the option.
• Computer setup: A PC/Mac with the Android SDK platform‑tools installed (so you have adb available). No Android Studio is required.
• Connection: Use a USB cable for the initial setup. The device should stay charged above 50 % to avoid accidental shutdowns during testing.
• Backup: The steps only change system settings, but if you plan to experiment with ADB commands that modify global settings, a quick backup of your data (via Settings > System > Backup) is a safe habit.

Step 1 – Enable Developer Options

1. Open Settings on your Android device.
2. Scroll to About phone (or About device).
3. Find Build number and tap it 7 times. You’ll see a toast message: “You are now a developer!”.
4. Return to the main Settings screen; a new entry called Developer options will appear, usually just above System or About phone.

Step 2 – Locate the network‑speed simulator

The exact wording varies by Android version, but the option lives inside Developer options.

1. Open Developer options.
2. Scroll down to the Networking section.
3. Find the entry named Simulate network speed or Network speed. On some devices it appears as Network bandwidth.
4. Tap the entry; a list of preset speeds appears: Full speed, 4G, 3G, 2G, LTE, and sometimes Edge or GPRS.

Select the speed you want to emulate. The system immediately limits both upload and download throughput to the chosen value, and also injects a modest amount of latency that matches typical real‑world measurements for that technology.

Step 3 – Verify the throttling is active

After you pick a speed, you should confirm that the limits are in effect. The simplest way is to run a speed‑test app that reports both bandwidth and latency.

1. Install a reputable speed‑test app from the Play Store (e.g., Speedtest by Ookla).
2. Run the test while the device is connected to Wi‑Fi (the simulator works on Wi‑Fi as well as cellular).
3. Compare the reported download/upload numbers with the values you selected. For example, choosing 3G should give you roughly 1–2 Mbps down and 500 kbps up, with latency around 150‑200 ms.

If the numbers are still close to your original Wi‑Fi speed, double‑check that you selected the correct entry and that the device didn’t automatically switch to a faster network (some phones prioritize cellular over Wi‑Fi when throttling is active).

Step 4 – Using ADB to toggle the simulator from a PC

While the UI method is handy for quick checks, you often need to switch speeds repeatedly during an automated test run. ADB provides a command‑line interface that can change the setting without touching the screen.

First, confirm that your device is visible to ADB:

adb devices

You should see a line with the device serial number and the word device. If not, enable USB debugging inside Developer options (toggle the switch at the top) and accept the RSA key prompt on the phone.

Once the connection is verified, use the following command to set the speed. The setting is stored in the global namespace under the key network_speed (the exact key name differs by Android version; the command below works on Android 9‑13).

adb shell settings put global network_speed <value>

Replace <value> with one of the following integers:

• 0 – Full speed (no throttling)
• 1 – 4G (≈20 Mbps down, 10 Mbps up)
• 2 – 3G (≈2 Mbps down, 1 Mbps up)
• 3 – 2G (≈250 kbps down, 100 kbps up)
• 4 – Edge (≈100 kbps down, 50 kbps up)

Example: to simulate a 3G connection, run:

adb shell settings put global network_speed 2

To revert to normal speed:

adb shell settings put global network_speed 0

After issuing the command, you can immediately run your speed‑test app again to verify the change.

Step 5 – Adding artificial latency with ADB (advanced)

The built‑in speed presets bundle both bandwidth limits and a modest latency value. If you need to test extreme latency (e.g., satellite connections with 600 ms RTT), you can combine the speed throttling with a Linux netem rule. Android does not expose tc (traffic control) by default, but you can install a tiny helper binary via adb push if you have a rooted device or a userdebug build.

1. Obtain a tc binary compiled for ARM64 (or ARMv7) and place it on your computer.
2. Push it to /data/local/tmp on the device:

   adb push tc /data/local/tmp/

3. Make it executable:

   adb shell chmod 755 /data/local/tmp/tc

4. Run a netem rule on the primary network interface (usually wlan0 for Wi‑Fi):

   adb shell "su -c '/data/local/tmp/tc qdisc add dev wlan0 root netem delay 600ms'"

5. When you’re done, delete the rule:

   adb shell "su -c '/data/local/tmp/tc qdisc del dev wlan0 root netem'"

This approach lets you set any delay, jitter, or packet‑loss pattern you need. Because it requires root, it’s best suited for internal QA devices rather than a consumer phone.

Step 6 – Automating speed changes in a test script

If you run UI‑automation tests (e.g., with adb shell am instrument or Appium), you can embed the ADB speed‑change commands directly in your script.

# Example Bash snippet
#!/bin/bash
# Set to 3G
adb shell settings put global network_speed 2
# Run your test suite
./run‑ui‑tests.sh
# Restore full speed
adb shell settings put global network_speed 0

Place the snippet at the beginning of each test case that needs a specific network condition. The script will automatically restore the normal speed afterward, ensuring later tests are not unintentionally throttled.

Step 7 – Common pitfalls and troubleshooting

• Option missing in Developer options: Some OEM skins hide the simulator. Try enabling it via ADB:

  adb shell settings put global development_settings_enabled 1

  Then reopen Settings. If the entry still does not appear, the device’s firmware simply does not support the feature.
• Wi‑Fi vs. cellular: The simulator works on both, but the UI sometimes shows a different list when you are on cellular only. Switch to Wi‑Fi if the list looks truncated.
• Speed does not change: Verify that no third‑party VPN or network‑optimizing app (e.g., Samsung’s “Smart Manager”) is overriding the bandwidth. Disable such apps temporarily.
• ADB command rejected: On Android 12+, the network_speed key is protected. Use the UI method or a rooted device.
• Latency seems unchanged: Remember that the built‑in presets add a fixed latency (≈100 ms for 2G, 150 ms for 3G). If you need higher latency, use the tc method described earlier.

Step 8 – Resetting everything safely

When you finish testing, it’s good practice to clear any lingering settings:

1. Open Developer options and set Simulate network speed back to Full speed.
2. If you used ADB, run:

   adb shell settings delete global network_speed

3. If you applied a tc rule, run the delete command shown in Step 6.
4. Re‑enable any VPN or performance‑boost apps you disabled earlier.

The device will now behave exactly as it did before you started the simulation.

What you can achieve with network simulation

With the steps above you can:

• Validate that loading spinners appear after realistic delays.
• Test exponential back‑off and retry mechanisms under high‑latency conditions.
• Measure how much data your app transfers on a constrained 2G link, helping you optimise payload size.
• Identify UI‑thread blocks that become visible only when the network is slow.

All of these checks lead to a smoother user experience for people on slower carriers, in remote areas, or on congested public Wi‑Fi.

Wrap‑up

Simulating a slow network on a real Android device is straightforward once you enable Developer options. The built‑in speed presets cover the most common cellular classes, and ADB lets you script rapid switches for automated test pipelines. For extreme latency or packet‑loss scenarios, a rooted device with tc netem provides full control.

By following this guide you’ll be able to reproduce the exact connectivity constraints your users face, catch performance bugs early, and ship an app that feels responsive even on the weakest link.