AngoraTek FR
← Back to Blog
Tutorials 7 min read

The Lab Says Fast. CrUX Disagrees.

2.5 seconds is Google's Good threshold for Largest Contentful Paint, and the verdict is measured at the 75th percentile, from real Chrome users, on their own phones and networks, over a rolling 28-day window. Your Lighthouse run simulates one load, on one device, in one network profile, with the cache state of a colleague's office laptop. The two numbers disagree on real sites, and when they do, the field number is the one your product is actually serving.

The claim you can check against your own CrUX data: lab data is a repair manual and field data is a scoreboard, so every performance meeting should open on CrUX and only then descend into the lab. Teams that run the loop in the opposite order debug their way to a green Lighthouse score while the 75th percentile of their actual visitors stays slow, because the lab never loads the page with the visitor's cache, the visitor's CPU, or the visitor's three tab-syncs fighting for the radio.

CrUX is the 75th percentile of people, not of your test runs

The Chrome User Experience Report collects Web Vitals measurements from Chrome itself, aggregates them per origin and (for pages with enough traffic) per URL, and publishes the result as a public dataset, queryable in BigQuery and summarized on every PageSpeed Insights report. The aggregation point matters more than the plumbing: Google publishes the 75th percentile because that percentile decides whether the site counts as Good. A page whose median load is fast but whose slowest quarter is slow does not get to claim the good number.

Three properties of the dataset change how you argue with it. The window is 28 days, so a regression shipped yesterday is invisible until the rolling tail moves past the affected days, which makes CrUX a scoreboard with a delayed broadcast, not a smoke test. URL-level rows exist only where traffic supports them, so the route you most want to interrogate may only exist merged into its origin. And the measurement units are people: no test runs, no throttling profiles, your actual distribution of devices, networks, and cache states.

One question arrives here from anyone who has run both: if the field is truth, why does a CrUX number move with no deploy in sight? Because people move. The 28-day distribution reweights with every school holiday, device release, and network change on the visitor side, and none of that appears in a changelog. Treat single-week moves in CrUX as weather and multi-week moves as signal, and the scoreboard stops being noisy at exactly the granularity you were about to over-read.

INP exists only in the field

Interaction to Next Paint replaced First Input Delay as the third Core Web Vital in March 2024, and it is the one metric your lab cannot fully produce. INP scores the worst-enough interaction over a page's life: every tap and click and key, each timed from input to the next painted frame. Lighthouse can simulate a load, but it cannot simulate your visitors' intent, so in the lab it stands in with Total Blocking Time, a proxy that measures main-thread congestion and not one real interaction.

The consequence is worth spelling out. A page can pass every lab check and still carry a bad INP, because the interaction that scored badly was a visitor mid-scroll firing a tap on a widget that only finished hydrating 40 seconds in, on a bus, over a connection the lab has never heard of. The same asymmetry runs in the other direction: real-world caching, including the back/forward cache Chrome applies aggressively, can make the field number better than any cold-load simulation. The lab cannot lie in both directions by accident; it lies by design, because simulation is the point.

Where the disagreement comes from

One worked page keeps this concrete: a blog archive page with a hero image as the LCP element and a category filter as the interaction people use. Run it in Lighthouse and in the field and the disagreements collect into four predictable buckets.

Cache state comes first. The lab loads cold; the field is mostly warm, except for the exact visitors you most need to convert, who are always cold. Device follows: throttled lab CPU is a shaped surrogate for a mid-tier chipset, and the shaping is blunt about compile costs, so a JavaScript-heavy page can look fine throttled and feel dead on the phone. Third parties follow: an ad script or a tag manager behaves differently every hour of every day, and the lab's single snapshot never samples the weather. And the field includes the distributions, tails, and caching that a lab by definition compresses away, which is why a p75 you cannot reproduce locally is not a measurement error.

The fixes that move the field numbers

Because CrUX aggregates people, a fix only registers when it moves the slow quarter, not the median. That reorders the usual worklist.

For LCP on the worked page, the hero image is the element, so the fixes that count are the ones that touch it before anything else: the image preloaded with fetchpriority="high", sized responsively so a phone never downloads the desktop file, served from a host that answers the first request quickly, with the fonts above it neither blocking nor late-swapping into a layout shift. Deferring a chat widget does nothing for LCP; trimming the hero does. The helpers below are your app's; the yields are the pattern.

// Split the filter work so each task stays short and the
// input handler paints before the loop continues.
async function applyCategory(filterRow) {
  markSelected(filterRow);            // pressed state first
  const chunks = splitRows(rows, 200);
  for (const chunk of chunks) {
    await new Promise((r) => setTimeout(r)); // yield to frames
    render(chunk);
  }
}

For INP, the filter above is the fix pattern: paint the pressed state, then yield, then render in slices. The general moves behind it are the same in any framework: do less in the input handler before yielding, break long tasks so the main thread can answer between them, and push the work that owns no pixels, analytics tags and embeds first among them, off the critical path of the interaction. These moves may not budge a Lighthouse score, and that is not the test. They are the moves that change the 75th percentile, because p75 is where slow devices and congested main threads actually live.

What the lab is still for

The scoreboard metaphor would be dishonest taken too far: CrUX tells you where you stand and never why, because it ships no trace, no request waterfall, and no single session to inspect. Debugging still happens in the lab, on the device, in DevTools. The honest division of labor is one sentence: field data finds the page and the metric, lab data finds the function.

Close the gap with measurement of your own if the aggregation is too coarse. The web-vitals JavaScript library records each metric the browser produces on your own pages, and sending those values into a sessionless analytics pipeline, in the shape we sketched in our post on privacy-first telemetry, gives you a distribution you can slice without a consent banner. You give up joining metrics to a session, which is the same trade as before, and in this case the field already gave you most of what a session would have.

One line closes it: a Lighthouse score is what your page does under questioning in a quiet room, CrUX is what it did in front of witnesses, and only the second number is admissible.

AngoraTek reads CrUX and field data first, then debugs in the lab, for sites and products of a few routes to a few hundred. If your team keeps celebrating green lab numbers the 75th percentile never saw, bring us the page and the metric and we will read the witnesses together.

Thanks for reading this far. If this sounds like the problem you're wrestling with, tell us about it. The team reads every message.

Start a conversation