.avif)
To simulate a slow network (or a slow internet connection) for app testing, you throttle three things at once: bandwidth (how many kbps), latency (round-trip delay in ms), and packet loss (the percent of packets dropped). You can do it on a device, in a proxy, in the Linux kernel or on a cloud farm; use whichever layer reproduces the bug. Most teams test only bandwidth, and that is the usual mistake. Real mobile networks drop and reorder packets, which is what breaks calls, uploads and reconnection logic.
People open your app on a crowded train, in a basement Wi-Fi dead zone, on a roaming SIM abroad or on in-flight Wi-Fi, and they expect it to work. If you skip those conditions in testing, the product will stall for a large slice of real sessions. Fora Soft has built real-time video, telehealth and streaming apps since 2005, and our QA team has throttled, dropped and degraded every mobile network it could find. This is the 2026 version of our internal playbook.
Key takeaways
- Pick the lowest layer that reproduces the bug. The options are an on-device toggle, browser DevTools, a proxy, a kernel qdisc, a cloud farm or hardware. Most bugs show up at the cheapest of those six layers.
- iOS developers get Network Link Conditioner free. It ships in Apple's Additional Tools for Xcode and runs on the device itself. In 2026 it is still the quickest way to degrade an iPhone.
- Packet loss and jitter break apps before bandwidth does. A 4G link with 8% loss fails more video calls than a 2G link at 0% loss. Test both, and test upload separately from download.
- Cloud device farms add throttling on paid tiers. BrowserStack keeps it on Team plans; AWS Device Farm bills $0.17 per device-minute. Use a farm when CI needs hundreds of device and OS combinations.
- Don't ship without a bad-network test matrix. We run five profiles (2G Edge, 3G HSPA, lossy 4G, high-latency, airplane-recover) on every release, and they catch most of the failures users report.
Updated November 2026: Charles 5.2.3, Toxiproxy 2.13.0, TestMu AI (formerly LambdaTest), Chrome 148 recommended throttling presets, and new answers on automation platforms, sensor emulation and music apps on poor networks.
Where you can throttle a network
You can degrade a network in six places, from a one-tap OS toggle up to line-rate hardware. The higher layers take less setup. The lower ones are more reproducible and affect every protocol the same way. New engineers on our team learn one rule: use the lowest layer that still reproduces the bug you are chasing.

Figure 1. The six layers where you can inject bandwidth caps, latency, and packet loss, with the tool and trade-off for each.
Two of those layers serve web and hybrid apps that never touch a native mobile network stack. Chrome DevTools has a Network panel with throttling presets and custom profiles, and Playwright can drive the same engine through the Chrome DevTools Protocol. For a web app or a WebView, the browser layer is often enough; the next section shows how, with Safari and slow APIs included. After that, the guide covers the seven tools that matter for native and cross-platform apps.
How to simulate a slow network in a web app or API
For a web app, use your browser's DevTools throttling; for a slow or unstable API, put Toxiproxy between your code and the service; on Windows, Clumsy degrades every app on the machine. Choose by what you want to break: the whole page, one endpoint, or the network under a native app.
Chrome and Edge DevTools. Open the Network panel → Throttling drop-down and pick Fast 4G, Slow 4G, 3G or Offline. A custom profile (Settings → Throttling) sets download and upload kbps, latency, packet loss, packet queue length and packet reordering, so DevTools models loss as well as speed. Since Chrome 145 you can also throttle or block an individual request: right-click it, choose throttle by URL or by domain, and the rule appears in the Request conditions drawer. This is the quickest way to simulate slow network errors in a web app. Slow down one API call or block it, then see whether the UI shows a spinner, a retry or a blank screen. Since Chrome 148 (May 2026) the throttling drop-down also highlights recommended presets built from your site's real-user CrUX field data, so you can test the connection your visitors actually have. Firefox has its own Throttling menu in the Network Monitor.
Playwright. As of November 2026, Playwright still has no built-in throttling option. In Chromium, open a CDP session and send Network.emulateNetworkConditions. For Firefox and WebKit runs, send the browser through a throttling proxy or delay responses with page.route.
const cdp = await page.context().newCDPSession(page);
await cdp.send('Network.emulateNetworkConditions', {
offline: false,
latency: 400, // ms
downloadThroughput: (400 * 1024) / 8, // 400 kbps
uploadThroughput: (128 * 1024) / 8, // 128 kbps
});
Safari. Web Inspector throttling in Safari started as an experiment that WebKit later switched off. The work to bring it back was merged into WebKit on 10 September 2026, so it should land in Safari Technology Preview before stable Safari; as of November 2026 it has not reached stable Safari. For now, simulate a slow network in Safari by turning on Network Link Conditioner on the Mac, which throttles every app on it.
Slow or unstable APIs. Toxiproxy (open source, from Shopify; v2.13.0, October 2026) is a TCP proxy you control over an HTTP API. Its “toxics” add latency with jitter, cap bandwidth, or cut, time out and reset connections, per upstream service. Teams use it to test retries, timeouts and circuit breakers in integration tests and CI without touching the device network.
Windows. Clumsy is a free, open-source bad connection simulator for Windows that adds lag, drops packets and tampers with them for the whole machine; Fiddler handles the HTTP-only case. QA labs use a simple trick: run Clumsy on a laptop, share its connection as a hotspot, and every phone that joins gets the bad network.
Why trust this playbook
We build real-time video, audio and live-streaming apps, where 100 ms of extra latency or 3% extra loss makes a call unusable. Across 250+ projects since 2005 we have run bad-network QA on iOS, Android, React Native, Flutter and Kotlin Multiplatform, from BrainCert's virtual-classroom platform to HIPAA telehealth and sports streaming for tens of thousands of concurrent viewers. Each section below says what a tool simulates, where its accuracy ends and when to switch to something else. If you'd rather we pressure-test your stack, Book a 30-min network-QA audit and we'll tell you where it breaks. For WebRTC products, our WebRTC consulting review covers jitter, loss recovery and TURN behaviour on real networks.
Reach for a proxy plus Network Link Conditioner when you want fast iteration and roughly 80% coverage without buying anything. Together they reproduce most realistic mobile-network conditions on iOS and Android.
1. Network Link Conditioner (iOS & macOS)
Network Link Conditioner is Apple's free developer tool that throttles bandwidth, latency, packet loss and DNS delay for an iPhone, iPad or Mac. In 2026 it is still the fastest way to slow one of those devices down. It runs on the device, with no proxy or extra hardware. Presets include Edge, 3G, LTE, Very Bad Network and 100% Loss, and custom profiles set bandwidth, packet loss and DNS delay independently.
On iPhone/iPad (iOS 17+): Settings → Developer → Network Link Conditioner → choose a profile → toggle on. If the Developer menu is missing, connect the device once to a Mac running Xcode. On Mac (macOS 14 Sonoma through macOS 26 Tahoe): Xcode → Open Developer Tool → More Developer Tools, then download "Additional Tools for Xcode" and install Network Link Conditioner.prefPane. It runs natively on Apple Silicon, without Rosetta.
iOS Simulator: the Simulator has no network switch of its own. It uses the Mac's network stack, so to throttle the iOS Simulator you turn on Network Link Conditioner on the Mac. That slows the Simulator, Safari and every other app on the Mac until you switch it off. From Xcode: with an iPhone connected, open Window → Devices and Simulators, select the device, pick Network Link and a profile under Device Conditions, and press Start. You get the same presets without opening the Settings app on the device.
2. Android Studio emulator throttling
The Android Studio emulator throttles at the virtual-modem layer, by cellular class. In the AVD Manager, open Advanced Settings and pick a Network Speed (GSM, HSCSD, GPRS, EDGE, UMTS, HSDPA, LTE) and a Network Latency profile. The command-line flags give you finer control than the UI: -netspeed edge, -netdelay umts, and adb shell cmd connectivity airplane-mode enable to script recovery.
Is there a Network Link Conditioner for Android? No. Developer options on Android have no network throttle, so the emulator is the nearest equivalent. On a running emulator, adb emu network speed edge and adb emu network delay gprs change the profile without a restart. For a physical Android phone, throttle the Wi-Fi it joins: a proxy, a tc + NetEm box, or a hotspot from a throttled laptop.
The emulator only sets a speed class. It has no jitter or loss controls, so add a proxy on top for those (see Charles below). A simulated modem also behaves differently from a real radio, so anything involving WebRTC or handovers needs a check on real devices. For more on Android alone, see our companion piece on simulating a slow connection on Android.
Skip the emulator when you ship in emerging markets. A simulated modem misses tower congestion and handover drops, which real devices on local carriers in the target country will show you.
3. Cloud device farms
All four big cloud farms throttle real hardware with network profiles: BrowserStack App Live, TestMu AI Real Device Cloud (LambdaTest renamed itself TestMu AI in January 2026), Sauce Labs and AWS Device Farm. Each gives you thousands of real iOS and Android devices with 2G/3G/4G/5G or custom profiles, through the UI and an API.
The marketing pages leave one thing out: on BrowserStack the Throttle Network feature is only on Team, Team Pro, and Enterprise plans (as of October 2026, Team starts at $150/month and Team Pro at $249/month billed annually), not on the $39 Individual tier, and custom profiles cap bandwidth at 50 Mbps. AWS Device Farm bills $0.17 per device-minute after a one-time 1,000-minute free trial (AWS marks it as a limited-time offer; the standard trial is 250 minutes), or $250 per unmetered slot per month. All four have CI plugins for GitHub Actions, CircleCI, Bitrise and GitLab CI.
4. Charles Proxy
Charles Proxy remains the general-purpose QA tool for HTTP(S) inspection and network degradation. Charles 5 shipped in March 2025, and the current release is 5.2.3, from 13 November 2026, which adds warnings for problems such as expired remote SSL certificates. Point your device's Wi-Fi proxy at your machine, trust the root cert, then open Proxy → Throttle Settings and set bandwidth up/down, latency, MTU, reliability (packet loss) and DNS delay, each on its own. Real networks are asymmetric and lossy, and setting each value separately is how Charles lets you model both.
Pricing (2026): $50 for a single-user license, $400 for a site license. It runs on macOS, Windows and Linux.
5. mitmproxy, Proxyman and tc + NetEm
If you don't want to pay for Charles, mitmproxy is free, open-source, written in Python and scriptable per request, so you can slow down one endpoint and leave the rest fast. Proxyman is an easier macOS front-end (as of October 2026, a perpetual Standard license is $89 and Team is $99 a seat or $12 a seat per month; throttling, which Proxyman calls Network Conditions, is a paid feature). For layer-3 degradation on Linux, tc + NetEm applies bandwidth caps, delay, jitter, loss and reordering in the kernel itself:
tc qdisc add dev eth0 root netem delay 200ms 50ms loss 5%
If your test devices route through a Linux box or a Docker rig, NetEm is almost always the right layer. It sits below the application and below UDP, so it treats every protocol the same, degrades QUIC exactly like TCP, and scales from one process to a full CI grid. The config is plain text, so it goes into version control.
Reach for tc + NetEm when you want reproducible network profiles in CI that live in git, or one Linux box in front of many test devices. It scales well and costs nothing.
6. Force a cellular generation
Sometimes you need a real carrier network at a real speed instead of a simulation. Force the device onto a specific cellular generation in OS settings. We do this as the last check before release, and it is the fastest way to match a report like "slow on 3G in rural areas".
iOS (18+): Settings → Cellular → Cellular Data Options → Voice & Data, then pick 3G/4G/5G (many regions' iPhones don't offer 2G-only, so use NLC for Edge). Android (14+): Settings → Network & Internet → SIMs → Preferred network type. The exact path varies with each manufacturer's skin.
7. Router QoS and hardware shapers
To throttle a whole office or device farm, set limits on the router or on a dedicated shaper. Routers running OpenWrt or DD-WRT expose tc + NetEm through a UI, and MikroTik or Ubiquiti enterprise gear has built-in QoS with per-SSID limits. Larger QA labs usually standardize on hardware WAN emulators such as Apposite Netropy, which apply impairment at full line rate.
Budget (2026): an OpenWrt router from about $60, or a MikroTik hAP ax2 from roughly $99. Pro: dedicated WAN emulators start in the low four figures. They pay off only if a shared lab runs many hours of network-degraded QA every week.
The 7 tools compared (2026)
| Tool | Platform | Controls | Price (2026) | Best for |
|---|---|---|---|---|
| Network Link Conditioner | iOS, macOS | Bandwidth, loss, DNS delay | Free (with Xcode) | Fast iOS on-device |
| Android emulator | Emulator (Android) | Cellular class, latency | Free | Smoke test in CI |
| Cloud device farm | Real iOS & Android | 2G–5G profiles | $0.17/dev-min or tiered | Broad coverage, CI |
| Charles Proxy | macOS/Win/Linux | Bandwidth, loss, jitter, DNS | $50 single license | Detailed manual testing |
| mitmproxy / tc + NetEm | Any (Linux for NetEm) | Full layer-3 + HTTP | Free | CI-scale, scriptable |
| Forced cellular generation | Real device | Real carrier behaviour | Free | Final-mile validation |
| Router QoS / WAN emulator | All devices on network | Full line-rate impairment | $60–low four figures | Lab-scale, deterministic |
Which tool should you pick?
Choose the tool by how you work. On a physical iPhone, start with Network Link Conditioner. For CI across many device and OS combinations, use a cloud farm. To set loss and jitter by hand, use Charles or tc + NetEm. To keep profiles reproducible in git, run NetEm in a Docker rig.

Figure 2. A fast triage for choosing a tool to simulate a slow network. Stop at the first row that matches your workflow.
What network-degraded QA costs
Free tools (NLC, emulator, tc + NetEm) are enough for most teams. Real money goes on cloud farms, and the choice between metered and fixed pricing is where budgets get burned. Here is the math for AWS Device Farm at 2026 pricing.
Say each build runs 8 devices for 25 minutes, which is 200 device-minutes, and you run 30 builds a month. That adds up to 6,000 device-minutes. Metered at $0.17 each, the bill is 6,000 × $0.17 = $1,020/month. Eight unmetered slots at $250 each cost $2,000/month flat, however much you run. At this volume metered is still cheaper; unmetered wins once each device passes roughly 1,470 device-minutes a month. Light or spiky testing stays cheaper on metered billing, while steady daily CI reaches the fixed-slot break-even quickly.

Figure 3. Metered vs unmetered device-farm cost worked end to end, so you can see where the line sits.
What actually breaks: loss vs bandwidth
Bandwidth is the easiest thing to test and the least likely to break a modern app. Sessions die from packet loss and jitter, and each app type reacts to them differently. A video call falls apart at 5% loss long before it runs short of megabits, while a large file upload depends on raw throughput and barely notices latency. Once you know which defect breaks your app, you know which profile to test first.

Figure 4. How five app types react to bandwidth, latency, loss, and jitter. Red is where each one fails first.
If you build anything real-time, weight your test matrix toward loss and jitter. Profile upload separately from download too, because mobile uplink is often several times slower than downlink. An app that uploads photos fine on Wi-Fi can stall badly on a cellular uplink.
Common failure mode: testing only bandwidth. Packet loss, jitter and DNS delay change app behaviour far more than a lower bitrate does, and a bandwidth-only test never catches them.
Our five-scenario bad-network test
We run these five profiles before every release of an app with any network component. They take about 15 minutes of QA time and catch most of what goes wrong in the field:
- 2G Edge (50 kbps down/up, 400 ms latency, 0% loss). Does the app load, or time out before first paint? This profile finds over-aggressive HTTP timeouts and missing skeleton states.
- 3G HSPA (1.6 Mbps down, 768 kbps up, 150 ms latency, 2% loss). This is the "slow" network real users hit most often. It tests lazy-loading, video preroll and API retry.
- Lossy 4G (10 Mbps down, 3 Mbps up, 80 ms latency, 5% loss). Think moving vehicles, crowded stadiums and poor roaming. It finds WebRTC and WebSocket reconnection bugs.
- High latency (10 Mbps, 400 ms, 0% loss). Satellite links and roaming far from home. It exposes chatty APIs, where every extra round-trip adds the full latency again.
- Airplane-mode-then-recover. Turn airplane mode on for 20 seconds, then off, and check that the app reconnects, re-authenticates and resumes uploads. Most "my app got stuck" reports come from this transition.
Simulating bad networks for WebRTC
Real-time video is the hardest case. WebRTC degrades on packet loss and jitter well before bandwidth runs out, so test it with tc + NetEm or Charles at the Wi-Fi/proxy layer with 2–8% loss and 50–150 ms of jitter, on top of a low bitrate. Test asymmetric loss as well. 1% down with 8% up is a nasty real-world profile: it breaks the media uplink while the UI still looks fine.
Our own video and audio streaming projects keep teaching the same lesson. A call that works perfectly in the office falls apart on a congested uplink, and only loss and jitter testing catches that before release. For the theory behind it, our Learn track on video streaming covers adaptive bitrate and congestion control.
Wiring bad-network tests into CI
Which automation platform tests slow network conditions? For real devices, use a cloud device farm: BrowserStack, TestMu AI (formerly LambdaTest), Sauce Labs or AWS Device Farm. Each takes a network profile as a run parameter in CI. For self-hosted pipelines, tc + NetEm in Docker degrades the whole network and Toxiproxy degrades single services.
Manual network tests run once per release and get skipped when the deadline slips. Put two or three degraded profiles into CI so they run on every pull request. They don't need to cover everything, but they do need to run automatically. A tc + NetEm profile in a Docker container is the simplest setup: the config is versioned, results are deterministic and there is no license cost. On a cloud farm, the network profile is one more run parameter in the pipeline.
The book · Volume 2 of 7
Video Streaming: A Complete Guide to Video Delivery: From Network Protocols and Transport to Ingest, HLS, and MPEG-DASH
Throttling tells you that your app breaks on a bad network; our transport volume explains why. It covers what the network does to a media stream, TCP versus UDP, congestion control, QUIC and HTTP/3, NAT and the glass-to-glass latency budget, so the five scenarios in your test plan map to real failure modes rather than guesses. Written by Nikolay Sapunov, CEO at Fora Soft.
Read it on Amazon →Kindle & paperback · Fora Soft Video Engineering Handbook
Five pitfalls we've paid for
- Testing bandwidth but no packet loss. Real mobile networks lose packets, especially during handover. Test at least 2% loss on slow profiles and 5% on lossy ones.
- Forgetting asymmetric links. Mobile uplink is often several times slower than downlink. If you don't profile upload and download separately, you will miss upload stalls.
- Trusting emulator throttling. A simulated modem doesn't reproduce radio effects such as tower handover. Use it for smoke tests and confirm on real devices before release.
- Not testing recovery. A steady "slow network" test misses the transitions: slow to fast, offline to online, a drop mid-upload. In our experience recovery bugs outnumber steady-state ones.
- No CI integration. A test that runs only when someone remembers protects nothing. Put two or three profiles into CI and run them on every PR.
When not to simulate a slow network
Simulation stands in for reality, and some cases need the real thing. If a bug only appears on one carrier, a simulated profile will mislead you; force the real cellular generation and reproduce it live. If you ship to an emerging market with congested towers, a lab profile understates the problem, so budget for real-device testing in that region. If your app needs the network only for a login call, five throttled profiles are too many and one 3G-with-loss smoke test is enough. Use simulation for cheap, frequent regression runs and real networks to confirm the fix.
FAQ
What's the single most important bad-network profile to test?
3G HSPA with 2–3% packet loss and 150 ms latency. It matches the "slow" experience real users hit most often in 2026: on transit, in crowded venues and on rural cellular. An app that works well on this profile handles most bad networks.
How do I simulate a slow network in Chrome DevTools or Playwright?
In Chrome DevTools, open the Network panel and pick Fast 4G, Slow 4G or 3G, or add a custom profile with kbps, latency and packet loss; since Chrome 145 you can also throttle a single request. Playwright has no built-in throttle, so in Chromium you send Network.emulateNetworkConditions through a CDP session. In Safari, use Network Link Conditioner on the Mac.
Does Network Link Conditioner work on Apple Silicon Macs?
Yes. On any Apple Silicon Mac running macOS Sonoma, Sequoia or Tahoe, install Additional Tools for Xcode from developer.apple.com and drag Network Link Conditioner.prefPane into System Settings. It runs natively on Apple Silicon, without Rosetta.
Can I test network pathologies in React Native or Flutter?
Yes. Network degradation happens at the OS or proxy layer, below the framework, so every tool here works the same for React Native, Flutter, Kotlin Multiplatform or native apps. New React Native projects no longer bundle Flipper (since 0.74), and React Native DevTools added a Network panel in 0.83 (December 2025) without throttling so far, so use the OS and proxy tools.
How do I simulate bad networks for WebRTC video calls?
Use tc + NetEm or Charles at the Wi-Fi/proxy layer with 2–8% packet loss and 50–150 ms jitter. WebRTC reacts to loss and jitter far more than to raw bandwidth, and both hurt audio and video quality before bitrate does. Test asymmetric loss too, for example 1% down and 8% up.
Which tool integrates best with CI?
Cloud device farms (BrowserStack, TestMu AI (formerly LambdaTest), Sauce Labs, AWS Device Farm) all take the network profile as a run parameter and have official CI plugins. For local or self-hosted CI, tc + NetEm in a Docker container is the simplest option: versioned config, deterministic and free.
How do I throttle the network in the iOS Simulator?
Turn on Network Link Conditioner on your Mac. The Simulator has no network switch and shares the Mac's network, so the Mac-wide profile (3G, Edge, Very Bad Network or custom) applies to it. Switch it off when you are done, because it slows every app on the Mac.
Is there a Network Link Conditioner for Android?
No. Android phones have no built-in network throttle. Use the Android emulator's -netspeed and -netdelay settings, or throttle the Wi-Fi the phone joins with Charles, tc + NetEm or a hotspot from a laptop running Clumsy.
How do I simulate a slow or unstable API?
Put Toxiproxy between your app and the API and add latency, bandwidth, timeout or reset toxics per service. For a quick manual check, throttle or block that one request in Chrome DevTools (Chrome 145+). Then check that the app shows a retry or error state and does not hang.
How do I fake a bad internet connection on Windows?
Use Clumsy, a free open-source tool that adds lag and drops packets for the whole Windows machine. Share that machine's connection as a hotspot, and any phone on it gets the same bad network.
What is the best way to handle flaky mobile or Wi-Fi connections in real-time apps?
Design for reconnection, then prove it under loss: ICE restart and signalling reconnect for WebRTC, exponential backoff with jitter for WebSockets, and resumable uploads, all tested at 5% loss and through an airplane-mode toggle. Our video chat app development team builds and tests these recovery paths in every calling product.
Which developer tools emulate mobile sensors and throttled networks for app preview testing?
For web previews, Chrome DevTools does both: the Network panel throttles the connection and the Sensors panel overrides geolocation and device orientation. For native apps, the Android emulator's Extended controls simulate location and virtual sensors alongside its network speed settings, and Xcode's Simulator sets a location while Network Link Conditioner on the Mac slows its network.
What do music apps that work well in poor network conditions do differently?
They lower the bitrate and cache ahead. Spotify, for example, streams on Automatic quality by default, which follows the connection, and offers Low (about 24 kbit/s) through Very high (about 320 kbit/s), with separate cellular and download settings, according to its support page. To copy the pattern, test on a 3G profile with loss and check three things: low-bitrate fallback, offline downloads and a buffer that survives a short dropout.
Do I need to test 5G?
Only for apps that depend on ultra-low latency, such as AR, cloud gaming or real-time multiplayer. For most apps 5G behaves like fast 4G, so passing on 4G means passing on 5G. Millimeter-wave 5G does have propagation quirks worth testing for AR and live-streaming products.
Is HTTP/3 / QUIC testing different?
QUIC handles packet loss better than HTTP/2 over TCP because it avoids head-of-line blocking across streams, so apps on QUIC cope better with lossy links. If your CDN auto-negotiates, test both stacks. tc + NetEm works below UDP, so it degrades QUIC exactly like TCP.
Sum up
To simulate a slow network in 2026, pick the layer that fits your workflow and reproduces the bug. Network Link Conditioner is the fastest start on iOS, the Android emulator handles smoke tests, and cloud farms add device coverage and CI. For precise control, Charles or tc + NetEm set bandwidth, loss, jitter and latency independently. Forced cellular and router QoS cover validation on real networks.
The tools are free or cheap; keeping the tests running is the hard part. Put at least three bad-network scenarios into CI, test recovery as hard as steady state, and profile upload and download separately. Users on crowded trains, roaming SIMs and in-flight Wi-Fi notice the difference, and they are the most likely to churn. If you want help hardening your app, our troubleshooting and optimization team does this work, and our QA reporting template shows how we write it up.
Read next
Android
Simulate a Slow Internet Connection on Android
The Android-only deep dive: emulator, ADB, and proxy methods.
Mobile
Optimize Android Apps for Video Streaming in 2026
ABR, HEVC, AV1, and ExoPlayer settings that save bandwidth.
QA & Testing
How to Report on Software Testing
Status, risk, and coverage summaries your PM will actually read.
Services
Software Troubleshooting & Optimization
Performance, flakiness, and regression hunts on mobile and web.
