Core Web Vitals
Three field metrics for how a page feels to real visitors: Largest Contentful Paint for loading, Interaction to Next Paint for responsiveness, Cumulative Layout Shift for visual stability. They turn "it should be fast" into a number you can measure.
What it is
Core Web Vitals are the three metrics in Google's Web Vitals program that it treats as the minimum set for judging a page's experience: Largest Contentful Paint (LCP) for loading, Interaction to Next Paint (INP) for responsiveness, and Cumulative Layout Shift (CLS) for visual stability. They're field metrics: the values that matter come from real visits, and a page passes when all three meet their target at the 75th percentile of page loads, with mobile and desktop measured separately. The set isn't fixed. INP became a Core Web Vital in 2024 and retired First Input Delay (FID), which had measured the input delay of the first interaction and nothing after it.
LCP is the render time of the largest image or text block visible in the viewport, counted from when the navigation started. That clock includes redirects, connection setup and the wait for the first byte of HTML, which can make field LCP differ from a lab run. The candidates are img elements, an image element inside an svg, video elements (poster or first frame, whichever is earlier), elements with a CSS background image set through url(), and block-level elements that contain text. Size counts the part inside the viewport, so a tall image clipped at the fold is scored by what shows. As the page renders, the browser reports each new larger candidate and stops reporting once the visitor taps, scrolls or presses a key. Good is 2.5 seconds or less.
INP watches all clicks, taps and key presses over the whole visit and reports the longest one, discarding one worst interaction per 50 to soften random hiccups on busy pages. An interaction is timed from the moment the person begins it until the browser can next paint a frame, and that span has three parts: input delay (the main thread was busy before any handler ran), processing duration (the handlers themselves) and presentation delay (layout and paint before the frame appears). Hovering, zooming and scrolling aren't observed. Good is 200 ms or less, needs improvement up to 500 ms, poor above that. A page where no one clicked, tapped or typed reports no INP at all.
CLS is the largest burst of unexpected layout shifts during the page's life. A layout shift is a visible element changing position between two rendered frames, and its score is the impact fraction (how much of the viewport the moving elements touched across both frames) multiplied by the distance fraction (the farthest any of them moved, divided by the viewport's larger dimension). A burst, called a session window, groups shifts that are less than a second apart, up to five seconds in total; the window with the highest sum is the page's CLS. Shifts within 500 ms of a tap, click or key press carry a hadRecentInput flag and are excluded, but a scroll, drag or pinch doesn't count as recent input. Good is 0.1 or less; poor is more than 0.25.
<!-- If the first post's image is the LCP element on your feed: -->
<!-- discoverable in the HTML (src, not data-src), high priority, not lazy, sized. -->
<img
src="/media/post-1.jpg"
srcset="/media/post-1-480.jpg 480w, /media/post-1-960.jpg 960w"
sizes="100vw"
width="960" height="540"
fetchpriority="high"
alt="..."
/>
<!-- Later posts: lazy is fine, but still reserve their space. -->
<img src="/media/post-9.jpg" width="960" height="540" loading="lazy" alt="..." />
<!-- A slot whose final height you don't know: a floor beats 0px. -->
<div class="ad-slot" style="min-height: 250px"></div>When to use it
When the question is the first screen on a slow phone, it's an LCP question. Decide which element will be the largest candidate (on a feed, check whether it's the first post's image or its text block) and shorten its path. Two findings from the 2024 Web Almanac explain the usual fixes: 73% of mobile pages had an image as the LCP element, and 35% of those images had URLs the browser couldn't find in the initial HTML. So put the image in an img element with a real src or srcset rather than a data-src that waits for JavaScript, prefer server rendering so the markup arrives with the image in it, add fetchpriority="high", and take loading="lazy" off that one image, because lazy loading first checks whether the image is near the viewport. If the image lives in CSS or JavaScript, a link rel="preload" tag in the HTML gives the preload scanner something to find. A CDN that serves and caches close to the visitor cuts the time to first byte that LCP also counts.
When the question is a press that feels stuck, it's an INP question. A task longer than 50 ms is a long task, and long tasks hold the main thread so an input waits before its handler even starts. Break work up and yield; scheduler.yield() does that while keeping the rest of the work at the front of the queue, in Chrome 129 and Firefox 142 but not Safari, so a fallback is needed. Rendering counts too: INP runs until the next frame paints, so a huge re-render after a tap is part of the score. Avoid forced layout and layout thrashing, keep the DOM small (layout cost grows with DOM size) and use CSS containment to skip rendering off-screen content. On a feed that keeps appending posts, the DOM is the thing that grows, which is why list virtualization is an INP fix as much as a memory one. A fast visual acknowledgment (a pressed state, a spinner) in the first frame also lowers INP, since the metric stops at the next paint, not at the finished work.
When content arrives after the page is on screen, it's a CLS question. Reserve the space first. Give images width and height attributes or the CSS aspect-ratio property, which lets width follow the screen while the browser computes height; 66% of pages in the 2024 Web Almanac still had at least one unsized image, which starts at 0px tall and can shift the content below it when it loads. For ads, embeds and other slots of unknown size, a sensible min-height is usually better than the default 0px. Animate with transform instead of height, top or margin, and be careful with banners that slide in and shove content. Shifts right after a tap are forgiven, so a button that expands a post is fine; a feed that inserts new posts above what someone is reading is not.
When you've named a target, say how you'd know you hit it. The Chrome User Experience Report collects anonymized field data per Core Web Vital without any instrumentation on your side, and the web-vitals JavaScript library reports the same metrics from your own pages to your own analytics. Our advice: in a round, the sentence that lands is "I'd check the 75th percentile LCP for mobile in the field after launch", not "Lighthouse says 2.1 seconds on my laptop".
When not to
A lab score isn't the metric. Lighthouse and DevTools measure LCP and CLS in a simulated load, which is the right tool while you're building and for catching a regression before release. But Lighthouse has no INP value, because a simulated load has no one pressing anything; Total Blocking Time (TBT) stands in for it, and a TBT gain in the lab may carry over to INP in the field. Don't present a lab number as the result; present it as the thing you checked before shipping.
A route change inside a single-page app is, for most tooling, not a page. The metrics were defined relative to the top-level navigation: when an SPA swapped content and updated the URL, nothing reset, and the values stayed attached to the URL that started the load. Chrome 151 added soft-navigation APIs that the latest web-vitals library and DevTools use, and the Chrome User Experience Report publishes those metrics as experimental as of October 2026, aiming to graduate them in May 2027; other engines don't support them, so there the metrics still cover full page loads. Metrics that accumulate over a page's life, like CLS and INP, can also be harsher on an SPA where one "page" lasts the whole session. If your design is a route change, say which measurement you mean before quoting a threshold.
Some slowness isn't in the three. Scroll smoothness isn't INP, because scrolling isn't an observed interaction, so a janky feed can still have a good INP. A slow server shows up inside LCP but is better diagnosed with Time to First Byte, and render-blocking CSS with First Contentful Paint; both are supporting metrics rather than Core Web Vitals. And a tool used by a handful of people on fast desktops has too few visits for a percentile to mean much; there, a lab budget and a profiler are the honest tools.
Compared
| Measurement | What it tells you | Reach for it when | What it misses |
|---|---|---|---|
Field Core Web Vitals (CrUX, RUM) | What real visitors got, at the 75th percentile, by device type | You're claiming a page is fast for users, or deciding what to fix first | Arrives after launch; CrUX needs enough traffic and hides which element or script caused it |
Lab run (Lighthouse, DevTools) | Repeatable LCP and CLS under one simulated device and network | You're building, or need to catch a regression before release | Lighthouse has no INP (no one presses anything); a lab run misses slow phones, far-away users and real data |
Total Blocking Time (TBT) | A lab proxy for INP that needs no user input | You need a lab stand-in for INP | A proxy: a good TBT may not become a good INP once real taps arrive |
TTFB and FCP | Whether the server response or render-blocking resources are what slows the load | LCP is slow and you need to know where the budget went | Supporting metrics, not Core Web Vitals; a good FCP doesn't mean the main content showed |
Soft-navigation metrics (Chrome 151+) | Core Web Vitals for SPA route changes | Your product is an app whose "pages" are route changes | Experimental in CrUX as of October 2026; other browser engines don't report them |
In a picture
Step 1 of 4
The HTML arrives
The clock for LCP starts at navigation, so redirects, connection setup and the server's time to first byte are already on it before any markup is parsed.