Why Users Drop Off at Checkout: Find the Step and the Cause
Checkout drop-off is rarely a mystery once you compare the people who left with the people who paid. Here is a practical method to find the exact step and the technical cause behind it.
To find why users drop off at checkout, first measure each step so you know exactly where people leave, then compare the visits that left at that step with the visits that continued: failed requests, JavaScript errors, slow page loads, form fields the browser refused, a payment provider error, or one browser or device that fails far more often than the rest. The cause is almost always in that difference, not in the overall numbers.
Some abandonment is normal. Baymard Institute's long-running average puts cart abandonment at around 70%, and most of it is people comparing prices or not ready to buy. You cannot fix that with code. What you can fix is the part where people wanted to pay and your app stopped them. That part hides inside the same drop-off number, which is why "conversion is down" so often turns into weeks of copy changes while a broken request does the damage.
Step 1: Record Each Checkout Step and Each Failure
You need two kinds of events per visit: the steps (cart, checkout, payment, order placed) and the failures (JS errors, failed requests). A small script is enough to start.
function getSessionId() {
let id = sessionStorage.getItem('sid')
if (!id) {
id = crypto.randomUUID()
sessionStorage.setItem('sid', id)
}
return id
}
function track(name, props = {}) {
const body = JSON.stringify({
name,
session_id: getSessionId(),
path: location.pathname,
ts: new Date().toISOString(),
props,
})
navigator.sendBeacon('/api/events', new Blob([body], { type: 'application/json' }))
}
// Failures
window.addEventListener('error', (e) => track('js_error', { message: e.message }))
window.addEventListener('unhandledrejection', (e) => track('js_error', { message: String(e.reason) }))
const originalFetch = window.fetch
window.fetch = async (...args) => {
const url = args[0] instanceof Request ? args[0].url : String(args[0])
try {
const res = await originalFetch(...args)
if (!res.ok) track('request_failed', { url, status: res.status })
return res
} catch (err) {
track('request_failed', { url, status: 0 }) // network failure
throw err
}
}
track uses sendBeacon, not fetch, so the wrapper never reports its own calls. Then call track('checkout_view') when the checkout page renders and track('order_placed') when the order succeeds.
Step 2: Compare Who Left With Who Continued
With events in a table (session_id, name, ts, path, device, props as jsonb), this PostgreSQL query shows how often a JS error or failed request happened after checkout, split by whether the visit ended in an order:
WITH s AS (
SELECT session_id,
min(ts) FILTER (WHERE name = 'checkout_view') AS at_checkout,
bool_or(name = 'order_placed') AS ordered,
max(device) AS device
FROM events
WHERE ts >= now() - interval '7 days'
GROUP BY session_id
),
flagged AS (
SELECT s.*,
EXISTS (
SELECT 1 FROM events e
WHERE e.session_id = s.session_id
AND e.ts >= s.at_checkout
AND e.name IN ('js_error', 'request_failed')
) AS had_error
FROM s
WHERE s.at_checkout IS NOT NULL
)
SELECT ordered,
count(*) AS sessions,
round(100.0 * avg(had_error::int), 1) AS pct_with_error
FROM flagged
GROUP BY ordered;
If 2% of buyers hit an error but 30% of leavers did, you have found a technical cause, not a pricing one. Group the failed requests by props->>'url' and props->>'status' to see which call it is.
Step 3: Check Speed at the Step
A checkout page that takes six seconds to show its form loses people who never see an error. Record Largest Contentful Paint per page view:
let lcp = 0
new PerformanceObserver((list) => {
const entries = list.getEntries()
lcp = entries[entries.length - 1].startTime
}).observe({ type: 'largest-contentful-paint', buffered: true })
let sent = false
document.addEventListener('visibilitychange', () => {
if (document.visibilityState === 'hidden' && lcp && !sent) {
sent = true
track('lcp', { ms: Math.round(lcp) })
}
})
Compare the 75th percentile for leavers and buyers on the checkout page. A clear gap means speed is part of the story.
Step 4: Catch Form Fields the Browser Refused
Built-in validation (required, type="email", pattern) blocks submission without any error reaching you. The invalid event does not bubble, so listen in the capture phase:
document.addEventListener('invalid', (e) => {
const v = e.target.validity
const reason = ['valueMissing', 'typeMismatch', 'patternMismatch', 'tooShort',
'tooLong', 'rangeUnderflow', 'rangeOverflow', 'stepMismatch', 'badInput']
.find((k) => v[k]) || 'customError'
track('field_refused', { field: e.target.name, reason })
}, true)
Send the field name and the reason, never the value. A postcode pattern that rejects valid foreign postcodes shows up here within a day.
Step 5: Log Payment Provider Errors on the Server
The browser only sees "payment failed". Your server knows whether it was a declined card or the provider being down, and those need different fixes.
app.post('/api/orders', async (req, res) => {
try {
const order = await placeOrder(req.body) // calls your payment provider
res.status(201).json(order)
} catch (err) {
console.error(JSON.stringify({
event: 'payment_failed',
type: err.type, // e.g. 'StripeCardError' with Stripe
code: err.code, // e.g. 'card_declined'
status: err.statusCode,
}))
const declined = err.type === 'StripeCardError'
res.status(declined ? 402 : 502).json({
error: declined ? err.message : 'Payment is temporarily unavailable. Please try again.',
})
}
})
Declines at a steady rate are normal. A burst of 5xx or timeouts from the provider is an outage you should hear about. For the webhook side, see our guide to Stripe webhook failures.
Step 6: Segment by Device and Browser, Then Watch a Few Visits
Many checkout bugs live in one place: a Safari-only date input, a payment widget that breaks on small screens. Using the flagged CTE from Step 2:
SELECT device,
count(*) AS reached_checkout,
round(100.0 * avg((NOT ordered)::int), 1) AS drop_pct
FROM flagged
GROUP BY device
HAVING count(*) >= 30
ORDER BY drop_pct DESC;
A segment whose drop rate is far above the rest is your lead. Then watch three to five real visits from that segment that left at the step. Numbers tell you where; a handful of visits usually tells you what. Our post on session replay for production errors covers that part, and a dead checkout button is a common thing to find.
How Relia Finds the Step and the Cause
Relia does this method for you, from the page views, clicks, form submits and requests its SDK already records. It finds your main journeys itself: goals are successful write requests, form submits, and finish or critical pages, and the steps are the pages most people who reached the goal passed. In a demo shop, Relia's checkout journey reads Home 4,928, Products 4,928, Product page 3,707, Cart 2,043, Checkout 1,042 visits: 21.1% conversion, with the biggest loss (1,664 visits) after the product page.
Open a step and Relia shows why people left it: where they went next and where they came from, failed requests and JS errors after the step, form fields the browser refused, rage and dead clicks, the step page's LCP for leavers versus those who continued, devices, browsers, countries or sources with a drop rate at least 1.5 times the step's, open incidents on that page or the next API, and example visits to watch.
Relia also watches conversion. When a funnel's last hour converts at least 40% worse than the same hour on the previous days, it becomes an incident that names the step that lost the people. Relia never changes your code or opens pull requests; you make the fix.
Free includes the funnels Relia finds (3 watched) and drop alerts. Your own funnels and the "why" panel are on Growth ($19 a month) and Pro ($49 a month).
FAQ
What checkout drop-off rate is normal?
It depends on your product and traffic, so compare against yourself: the same step last week, and leavers against buyers. A step whose drop changes suddenly, or a segment that drops far more than the rest, matters more than any benchmark.
Should I track every click to find the cause?
No. Steps, JS errors, failed requests, LCP and refused form fields cover most technical causes. Add more only when those do not explain the gap.
How many sessions do I need before segment numbers mean anything?
Ignore segments with fewer than about 30 visits at the step. Small groups swing wildly, and a single bad visit can make a browser look broken.