
Checkout Usability
Part of Checkout performance
Testing checkout on slower mobile connections
Build a repeatable slower-mobile checkout test, record network and CPU conditions, and verify payment and order outcomes.
Create a realistic slow-mobile throttling setup
The Network panel's throttling dropdown offers Fast 4G, Slow 4G and 3G presets. They are enough to start a checkout test without any setup. While throttling is active, DevTools shows a warning icon beside the Network tab, so you can confirm it still applies when you move to another panel.
For closer emulation of real shoppers on a poor connection, build a custom profile: open the throttling menu and choose Custom > Add. Set the profile name, download and upload speeds in Kbps, latency in milliseconds, and the packet parameters — packet loss in per cent, packet queue length as a number, and a packet reordering flag that is either on or off.
Tick Disable cache to emulate a first visit. DevTools switches off the browser cache, so requests are not served from cache as they would be for a returning shopper. A checkout tested with a warm cache understates load time on the cart and payment steps.
Use the Network Conditions drawer to keep throttling and cache disabling active while you work in other panels.
DevTools has throttled WebSocket connections since version 99. Create a deliberately slow custom profile, such as 10 kbit/s, and select it. Compare message timings on the WS filter with and without throttling — useful where checkout status updates arrive over a socket.
Select Offline in the throttling dropdown next to Disable cache to simulate a device with no data connection at all. This is the quickest way to check what a progressive web app built with a service worker does when the shopper loses connectivity mid-checkout.
If field metrics are enabled in the Performance panel, one of the throttling options may be marked as recommended, based on Chrome UX Report data for the page. That gives you a preset tied to how the site actually performs for its users, rather than a generic 3G setting.
Key network and CPU throttling settings for mobile emulation
- Recommended CPU throttle
- 4x slowdown (calibrated via DevTools)
- Network recommendation source
- Derived from Chrome UX Report data when live metrics enabled
- Offline mode
- Simulates no data connection — tests service worker resilience
Run the checkout flow under throttled conditions
Turn on Capture screenshots in the Network panel settings, then reload and step through cart, details, payment and confirmation. Each thumbnail shows what the shopper saw while the requests around it were still in flight.
Tick Preserve log so the request table survives page loads and redirects. Without it, you lose everything that happened on the cart page the moment the payment page loads — the part you need to inspect.
Identify which requests sit on the critical path between steps — payment scripts, address and shipping lookups, tax calls, analytics. A blocked next screen usually traces back to one of these, not the whole page.
Watch for controls that look usable but do not respond. A button that paints before its handler is attached, or a form that accepts input while validation logic is still downloading, is a failure the shopper experiences as a broken checkout.
Replay a single call instead of repeating the whole flow: select the request in the table and press R, or right-click it and choose Replay XHR. This isolates a slow or failing endpoint from the rest of the journey.
Note where the flow stalls rather than fails — the confirmation screen that waits on a slow server response, the spinner with no timeout, the second submission that follows a timeout. Record each one against the step where you saw it.
Measure what slow connections do to checkout UX
Opening the Performance panel starts recording Largest Contentful Paint and Cumulative Layout Shift immediately, and shows a rating of good, needs improvement or poor. Once you interact with the page, Interaction to Next Paint is recorded and rated as well.
The Interactions and Layout shifts tables below the metric cards list the element involved, the time, the duration for interactions and the score for layout shifts. Use the Clear button to empty both before a clean throttled run through checkout.
Pull field data from the Chrome UX Report under Performance > Next steps > Field data. You can map a development origin to a production origin, so visiting localhost:8080/page1 shows field data for example.com/page1 — relevant when the checkout template only exists locally.
Lab and field results will differ. Lab LCP is affected by redirects, server connection latency and uncached data; lab CLS is typically lower than field CLS because lab tools load the page without interacting and capture only initial layout shifts.
INP cannot be measured in the lab at all, because it needs a real interaction.
Look at the tail of the distribution, not the middle. Field data usually shows wide variation between fast and slow users, and aggregation by median can hide that. Google judges Core Web Vitals against the percentage of good experiences; 75 per cent of page views must meet the good threshold for each metric.
Calibrate CPU throttling presets in Settings > Throttling: click Calibrate and wait about five seconds while DevTools navigates away and reloads the page. The result gives rates that approximate low- and mid-tier mobile performance, and the presets then appear in Performance > Environment settings > CPU.
In current DevTools, the recommended CPU throttling option is 4x slowdown, and the network recommendation is derived from Chrome UX Report data when live metrics are enabled.
Lab vs Field Core Web Vitals data: key differences
- Largest Contentful Paint (LCP)Lab: affected by redirects, server latency, uncached data; Field: reflects real user conditions
- Cumulative Layout Shift (CLS)Lab: typically lower due to no user interaction; Field: captures dynamic layout shifts from real use
- Interaction to Next Paint (INP)Lab: cannot be measured; Field: requires real user interaction to record
- Threshold for good experience75% of page views must meet the 'good' threshold for each metric in field data
Test payment outcomes when the network is unreliable
A fetch() promise rejects only when the request itself fails — a malformed URL or a network error. It does not reject when the server responds with an error status such as 404 or 504, so a then handler that assumes rejection will treat a failed payment call as a success.
Check Response.ok and Response.status instead of relying on promise rejection. The distinction matters most on throttled mobile connections, where timeouts and dropped requests sit alongside ordinary server errors.
Handle the exception types separately: aborting a request through AbortController produces an AbortError, while a TypeError covers an invalid URL, credentials embedded in the URL, invalid option values, a permissions policy block or a network error such as lost connectivity.
Payment result codes describe the current state, not a final one. Result codes can change after you receive them, so do not use them to update your order management system — the status you acted on may already be stale.
Some codes require an action rather than a message. ChallengeShopper means the issuer requires the shopper to authenticate, IdentifyShopper means the device must be fingerprinted through the frictionless flow, and RedirectShopper means the shopper must complete authentication on an external page or app. Authentication-only integrations also return AuthenticationNotRequired and AuthenticationFinished.
Intermediate result codes mean the payment has not reached a final state — for example when the payment is completed but the final status cannot be obtained yet, or when the shopper needs more time to complete it. Treat these as pending and keep the confirmation screen honest about that.
Guard against duplicate orders after a timeout or a slow response. Before resubmitting, confirm the order's state with a status check rather than retrying blind, so a delayed response does not produce a second order and a second charge.
Validate on real mobile devices and platform throttling tools
On iOS, use Xcode's Network Link Conditioner in Developer settings to throttle the connection on a connected iPhone or iPad. This requires a Mac with Xcode installed, so plan it as a separate step from desktop browser testing.
On Android, apply proxy-based throttling with Charles Proxy to reproduce poor connectivity. Presets configured there throttle traffic for apps and browsers on the device without changing the application under test.
Where you cannot keep a physical device lab, run the same steps on real Android and iOS devices through a real device cloud, which removes the need to source and maintain the handsets.
Use real devices to confirm what the emulated runs suggested. Desktop emulation changes the network profile only; it does not reproduce the device's CPU, memory pressure or radio behaviour, and those affect how a throttled checkout actually feels.
Document a slow-connection checkout regression suite
Record the exact custom profile used for each test by its saved name, and note whether the cache was disabled. A result is only reproducible if the conditions are written down with it.
Save the profiles in Settings > Throttling so they can be selected from the throttling dropdown in the Network panel. Named profiles keep the suite consistent between testers instead of relying on each person rebuilding the same numbers.
Write down the steps and the failure modes observed at each step: which screen stalled, which request blocked the next step, which control stopped responding, which order was submitted twice.
Re-run the suite before each release and after changes to checkout scripts, payment integration code, images and third-party tags. These are the changes that most often reintroduce slow-connection problems on the cart and payment screens.
DevTools lists the throttling settings used beside each trace in the Recent sessions dropdown, so a capture carries its own conditions. Attach those captures to the suite rather than re-describing them in prose.



