The bug that costs a week lives on a phone nobody on the team has held. In Southeast Asia in 2025, 89% of smartphones shipped under $200 — devices with 2–4 GB of RAM and a WebView engine a couple of Chromium versions behind. The iPhone 15 on the desk reproduces nothing. A mini-program runs inside a host app that cannot be instrumented and on a network that cannot be watched, so the comfortable debugging loop — reproduce locally, fix, ship — does not apply. The only witness is the device, and the team has to go to it.

Remote debugging on real hardware is flakiest on low-end

Chrome's remote debugging over ADB runs on real Android, but low-end devices are exactly where it is least stable: USB debugging drops, wireless debugging adds latency that hides the race, and a phone at 2% battery throttles, dragging the CPU curve being watched down with it. The discipline that survives this is to treat the device as the source of truth from day one, not to reach for it only after the emulator fails. One team keeps a unit of every mainstream low-end model on hand and runs real-device regression in CI, rather than drifting on emulators.

Source maps vanish after release

The second trap is the stack. Locally the crash is app.js line 120; after the host or its minifier touches it, the returned crash stack is minified and the line numbers do not line up. Without source map upload and symbolication, a production error is an unlocatable mess. The correct practice is to ship source maps to a symbol server at build time and automatically restore them to source lines on crash report. Otherwise "a pile of production errors, nothing reproducible locally" keeps draining the whole team's patience.

MethodDesktopLow-end realProduction
Remote breakpointSmoothFlaky, dropsNone
Crash stackSource lineSource lineNeeds source map
ReproduceEasyHardVia user upload

Observability: let the device speak

What truly catches the rest is collecting crashes, jank, and network failures on the client and shipping them to the server, instead of waiting for a support ticket. One team, via remote crash reporting, found a specific API that hard-crashed on WebView 94 on a particular model — something none of their test devices ever showed. Without that reporting layer, the bug would have stayed filed as "a user's network issue."

The network layer has to be visible too

Crashes are only half the truth. The other half is network: which host, which network type, shows a spike in timeouts or failures for an endpoint. One team found via client reporting that their asset CDN silently dropped large files under a certain carrier's MTU setting — something their WiFi test environment never reproduced. Collecting network failures by host, network type, and endpoint dimension makes the device actually testify; otherwise "a user's network issue" keeps taking the blame.

Log sampling, not a firehose

Low-end storage and upload are precious; full logging backfires by dragging performance and eating user data. The practice that holds is sampling: keep only lightweight markers on critical paths daily, and attach a recent ring buffer on crash or anomaly. One team switched from full to "sampled plus crash-attached" and saw low-end performance complaints fall while no real bug was missed. Observability's goal is not to fill the device with logs, but to let the unreachable device explain what happened when it matters.

Crash-free rate is the only metric that travels

Crashes, jank, and failed-network events should roll up into a single crash-free percentage, sliced by host and device model, with an alert threshold that pages someone when it dips. The teams that survive low-end chaos are the ones that watch this number daily across the fleet, not the ones that wait for a review to mention a crash. One team set a 99.5% crash-free target and caught a WebView 94-specific failure within hours of a release because the rollup flagged the model, instead of letting it hide in a complaint nobody read.

The bottom line

In mini-program debugging, the source of truth was never the laptop but the device out of reach. Lay down remote debugging, source maps, and client observability on day one, and the device testifies for the team.

Sources