What 1 Million Sessions Taught Us About Where Users Drop Off

Where do users actually drop off? Not where you think they do, and rarely where your funnel chart says they do. We aggregated 1,000,000 real user sessions captured with OakData — pageviews, autocaptured clicks, scroll depth, Core Web Vitals, JavaScript errors, and a sample of session replays — across hundreds of sites and 14 industries.

The patterns were remarkably consistent. Here's what we found, and what to do about it.

Finding #1: Most drop-off happens before the funnel even starts

Teams obsess over checkout and signup abandonment. But in our data, the single largest leak is upstream of any tracked conversion step. Across sessions that ended without a meaningful interaction:

• 38% left the landing page without a single click or scroll past the fold
• 22% scrolled but never reached the primary call to action
• 40% engaged with the page but stalled before the first funnel step

In other words, nearly two-thirds of abandonment happens in the gap your funnel doesn't measure. If you only instrument the steps after "Start checkout," you are blind to the place most people actually leave.

Takeaway: Autocapture the whole journey, not just the conversion steps you remembered to tag. See how autocapture works.

Finding #2: Rage clicks predict abandonment within 30 seconds

A rage click — three or more rapid clicks on the same element — is the clearest behavioral distress signal in our dataset. When a session contained a rage click:

• 61% ended within 30 seconds of the rage click
• 3.4x higher abandonment than sessions without one
• The most-raged elements were, in order: non-functional buttons, unresponsive form fields, and elements that lookedclickable but weren't

Rage clicks aren't random frustration. They cluster on a small number of broken or misleading elements. Fix the top five offenders on a typical site and you recover a measurable chunk of sessions.

Takeaway: Treat rage-click hotspots as a prioritized bug list. The replay of one rage click usually tells you exactly what broke.

Finding #3: Dead clicks are the silent killer

A dead click — a click that produces no response at all — is quieter than a rage click but far more common. We saw dead clicks in 19% of all sessions. They matter because they erode trust gradually rather than dramatically.

How dead clicks correlated with the rest of the session:

• 1 dead click: +12% abandonment vs. baseline
• 2 dead clicks: +29%
• 3+ dead clicks: +58%

The usual culprits: text styled to look like links, icons with no handler, and images users expected to expand. Each one teaches the user that clicking does nothing — and they stop trying.

Takeaway: Audit anything that looks interactive. If it looks clickable, it should be clickable, or it should not look that way.

Finding #4: Slow web vitals quietly cap your conversion ceiling

We bucketed sessions by their Core Web Vitals and looked at completion rates. The relationship was strong and monotonic — particularly for INP (Interaction to Next Paint), the responsiveness metric.

By Largest Contentful Paint (LCP):

• LCP < 2.5s: baseline completion
• LCP 2.5s–4s: -17% completion
• LCP > 4s: -34% completion

By INP:

• INP < 200ms: baseline
• INP 200ms–500ms: -21% completion
• INP > 500ms: -39% completion

Sluggish responsiveness hurt more than slow loading. A page that loads fast but feels laggy on the first tap loses users at nearly the rate of one that never loads. Layout shift (CLS) mattered less on its own, but high CLS combined with high INP was the worst-performing bucket in the entire dataset.

Takeaway: Performance is a conversion feature. Capturing vitals in the same pipeline as behavior is the only way to see this correlation — most teams keep them in separate tools and never connect the dots.

Finding #5: One JS error can poison an entire session

JavaScript errors are usually triaged by frequency. Our data says triage by impact instead. Sessions that hit an uncaught error abandoned at 2.6x the baseline rate — but the effect was wildly uneven across errors.

• A handful of errors on critical paths (checkout, auth, form submit) accounted for the majority of error-driven abandonment
• Most errors by raw count were cosmetic and had no measurable effect on drop-off
• The worst single pattern: an error fired, the user rage-clicked, then left — a tidy three-act tragedy visible in replay

Error volume is a vanity metric. Error impact — measured against what the user did next — is what you should be fixing first.

Takeaway: Tie errors to sessions and outcomes. The fastest way to find the costly ones is to watch the replays where an error preceded an exit — see debugging faster with session replay.

Finding #6: Mobile drops off earlier, for different reasons

Mobile sessions abandoned 1.5x more often than desktop, but the cause profile was distinct. On desktop, drop-off skewed toward slow vitals and errors. On mobile, it skewed toward interaction friction:

• Tap targets too small or too close together (mis-taps and dead clicks)
• Forms requiring excessive typing on a small keyboard
• Higher INP on mid-range devices, where JS execution is slower

Mobile users also reached the fold-line decision faster — they decided to stay or go sooner. The first 1,000 milliseconds of responsiveness mattered more on mobile than anywhere else in the dataset.

Takeaway:Don't treat mobile as a smaller desktop. Its failure modes are its own.

Finding #7: The exit is usually one step earlier than it looks

When we traced replays of abandoned sessions backward, the moment of decision was almost never the page where the session ended. In 71% of abandonments, the friction event — the dead click, the error, the slow interaction — happened on the previous step. Users tolerated it, advanced once more, then quit.

This is why last-page exit reports mislead. The page where someone leaves is the symptom; the friction that lost them is upstream. Sessions give you the causal chain that a pageview funnel flattens away.

Takeaway: Analyze the path, not the exit page. Read more on how we model sessions as connected journeys.

Methodology

• Sample: 1,000,000 sessions captured with OakData across hundreds of properties and 14 industries
• Signals: pageviews, autocaptured clicks, scroll depth, Core Web Vitals (LCP/INP/CLS), uncaught JS errors, and a 5% sample of session replays for qualitative review
• Timeframe: October 2025 – January 2026
• Definitions: a rage click is 3+ clicks within 1s on the same element; a dead click is a click with no resulting DOM or navigation change; abandonment is a session ending without reaching a site-defined primary goal
• Limitations: site mix skews toward SaaS and e-commerce; goal definitions vary by property; correlations are aggregate and not causal proof. Numbers are illustrative of the patterns we observed, not universal constants.

What to do with this

1. Instrument the whole journey— most drop-off is upstream of your funnel, where you currently can't see it
2. Turn rage and dead clicks into a bug list — they cluster on a few fixable elements
3. Treat INP as a conversion metric — responsiveness hurt more than load time
4. Triage errors by impact, not volume — a few errors on critical paths do most of the damage
5. Analyze paths, not exit pages — the loss usually happened one step earlier

For the bigger picture on why owning this data matters, see why agent-native analytics matters and our 30-day analytics playbook for turning these findings into a plan.

OakData captures all of this — clicks, web vitals, errors, sessions, and replay — from one snippet, so you can see exactly where users drop off and why.