The real cost of a slow checkout

Why averages lie

When the average page-load improves by 200 ms, most teams celebrate. The conversion line barely moves. That is because the average hides the only customer who matters: the one on the slow connection, the older phone, the borderline patience. Improve their experience and the line moves. Improve the average and you have changed a number without changing a business.

The same pattern shows up everywhere in performance work. The customer at the median is fine. The customer at the 75th, 90th, and 95th percentile is who pays. Optimizing for the median is optimizing for the customer who would have converted anyway.

Latency selects against your best customers

Returning customers tolerate more friction than new ones. They are also worth more — their lifetime value is multiples of a first-time buyer's. A slow checkout silently filters out the most valuable cohort — the one most likely to come back, recommend, and spend again. You will not see it in the funnel because they never reached the funnel. They abandoned at the cart page and went to a competitor.

The same logic applies to high-intent traffic. The customer who has been ready to buy for an hour is the most sensitive to friction at the moment of decision. They will not retry on a flaky connection. They are gone in two seconds.

The cohorts a slow checkout hurts most

These cohorts overlap. The customer who left in 2.5 seconds was probably in three of them at once.

What we measure in checkouts

Cart and checkout are the most measurement-deserving pages on any e-commerce site. The minimum:

• p75 LCP on the cart and checkout pages, segmented by traffic source.
• Time to interactive on the payment step — the moment the customer wants to finish.
• Failure rate of the payment provider, by region and by method.
• Abandonment between "added to cart" and "started checkout" — a different problem than checkout itself.
• Time between "submit payment" and "success page rendered" — the part the customer rates the experience on.
• Error rate per field — the form is part of the checkout.

If you cannot pull each of these segmented by the cohorts above, the analytics is the first project, not the page itself.

Wins that cost nothing to deploy

Most checkout fixes are removals, not additions.

Remove the chat widget that loads on the payment page. Remove the analytics script that runs three times. Remove the upsell that fights with the primary CTA. Defer the marketing pixel until after the success page renders. Every removal compounds — and none of them require a refactor.

A concrete starter list:

• The marketing analytics tag that runs on every page, including checkout. Defer it.
• The chat widget. Disable it on the payment step.
• The recommendation carousel under the cart. Replace with a static block or remove entirely.
• The exit-intent popup. It interrupts the exact action you want completed.
• The cookie banner that takes 200 ms to script-load. Replace with a static one.
• Any third-party script with a <script> tag and no async or defer. Add one. Or remove it.

This list will save a second of load time on most checkouts. A second of load time is worth more than the next three campaign emails combined.

The Shopify-specific playbook

If you run on Shopify, the constraints are different — but the principles are the same. The wins we see most often on Shopify checkouts:

• Audit the apps. Every installed app injects some combination of JavaScript, Liquid changes, and asynchronous calls. Most of them are not earning their performance cost. Disable for a week and watch conversion.
• Use the native checkout. Custom checkouts on Shopify Plus look more on-brand and almost always perform worse than the native one. The native checkout is the most optimized surface on the platform.
• Defer Pixel and analytics. Shopify's built-in events fire reliably without help. Adding a third tracker rarely improves the data and always costs latency.
• Tune the theme. A well-built theme on stock Shopify is faster than the average headless build.

The temptation on Shopify is to add. The win is almost always to subtract.

Latency that comes from somewhere else

Sometimes the checkout is slow not because of the front-end but because of an upstream system:

• The payment provider has a slow API in your region. Switch providers or add a regional fallback.
• The tax service is doing a real-time lookup against an external vendor. Pre-compute or cache.
• The shipping calculator is calling three carriers synchronously. Run them in parallel; fail fast.
• The fraud check is blocking the submit. Move it to a post-submit asynchronous flow if the risk model allows.
• The order service is doing inventory reservation, email queuing, and analytics writes synchronously. Make it queue and acknowledge.

If you have squeezed the front-end and the LCP is still bad, the next layer down is where the time went.

The maintenance trap

Checkouts decay. A team ships a fast checkout in March, adds three pixels, two apps, a new fraud check, a localization tweak, and a banner by September. The checkout is now 800 ms slower and nobody noticed because it happened a hundred milliseconds at a time.

The fix is a monthly checkout review:

• Field LCP and INP on the cart and payment steps.
• A list of every third-party script firing on those pages.
• A list of every change deployed to checkout in the last 30 days.
• A 15-minute audit of the network panel on a real mid-tier mobile device.

Teams that hold this cadence keep their checkout in the green band for years. Teams that do not lose 5-10% conversion to creep by year two.

How we audit a slow checkout

When a client asks us to look at a struggling checkout, the first day is always the same:

1. Open the live site on a real mid-tier Android phone on a throttled 4G connection.
2. Add a product to cart, go to checkout, fill the form, submit.
3. Watch the network panel the entire time.
4. Note every script that loads, every render that delays, every form interaction that lags.
5. Cross-reference against the analytics for the cohorts most affected.

Half the problems are visible in the first five minutes. The other half are visible in the data. We have not yet audited a slow checkout where the issue was unexplainable — only ones where it was uncomfortable to admit.

The revenue case

A 1-second improvement in checkout LCP, on a $10M annual e-commerce business, is typically worth $200,000-$500,000 in incremental revenue. That is not a Lighthouse score. That is the line in next quarter's report. The work to get there is rarely glamorous — it is the boring removals, the deferred scripts, the audit of apps. The teams that take it seriously stay competitive. The teams that treat checkout performance as a Q4 project quietly lose the cohort that matters most.