Core Web Vitals in Plain Terms: LCP, INP, and CLS and the Numbers That Count
Performance
October 30, 2026
Uptime tells you whether a site answers. It doesn't tell you whether the page feels fast. Google's Core Web Vitals are three measurements of real-world user experience, and on any site that depends on search traffic or conversions, they're worth watching right next to uptime.
The three metrics
Google's web.dev documentation defines three Core Web Vitals:
Largest Contentful Paint (LCP) measures loading. It records when the largest image or text block in the viewport finishes rendering. Google's threshold for a good score is 2.5 seconds or less.
Interaction to Next Paint (INP) measures responsiveness. It looks at how quickly the page responds visually after a user clicks, taps, or types, across the whole visit. A good score is 200 milliseconds or less. INP replaced First Input Delay (FID) as a Core Web Vital in March 2024.
Cumulative Layout Shift (CLS) measures visual stability, meaning how much the content jumps around while the page loads. A good score is 0.1 or less.
Google recommends measuring at the 75th percentile of page loads, split by mobile and desktop. A page passes when at least 75 percent of visits hit the good threshold.
Field data versus lab data
Field data comes from real visitors. Google collects it in the Chrome User Experience Report (CrUX), which feeds tools like PageSpeed Insights and the Core Web Vitals report in Search Console.
Lab data comes from a test run in a controlled environment, such as Lighthouse. It's handy for debugging, but it doesn't always line up with what real users experience. INP especially depends on real interactions, so lab tools rely on proxies for it.
Common causes and fixes
Slow LCP:
- large, uncompressed hero images,
- slow server response,
- render-blocking CSS or scripts.
Fixes include serving properly sized images in modern formats, caching, and preloading the hero image.
Poor INP:
- long JavaScript tasks that block the main thread,
- heavy third-party scripts.
Fixes include breaking up long tasks, deferring non-critical scripts, and cutting back on third-party code.
High CLS:
- images and ads without reserved space,
- late-loading fonts or banners that push content down.
Fixes include setting width and height on images and embeds, and reserving space for dynamic content.
The three bands for each metric
Google groups every measurement into good, needs improvement or poor:
| Metric | Good | Needs improvement | Poor |
|---|---|---|---|
| LCP | 2.5 s or less | over 2.5 s up to 4 s | over 4 s |
| INP | 200 ms or less | over 200 ms up to 500 ms | over 500 ms |
| CLS | 0.1 or less | over 0.1 up to 0.25 | over 0.25 |
A page is assessed on its 75th percentile value for each metric. In everyday practice, that means a site can look fast on an office connection and still fail, because a quarter of its real visitors on slower phones and networks set the score.
Where LCP time actually goes
Google's guidance breaks LCP into four parts: time to first byte, the delay before the browser starts loading the LCP resource, the time to load that resource, and the delay before it is rendered. Looking at those parts tells you where to work. A slow first byte points to the server, hosting or a missing cache. A long resource load delay usually means the hero image is discovered late, for instance because it is set in CSS or injected by JavaScript. Long load time points to file size. A long render delay often means blocking scripts or styles.
Why INP is harder than FID was
First Input Delay only measured the delay before the browser began handling the first interaction. INP covers the whole visit and includes the time to run the event handlers and paint the next frame. Pages that passed FID easily sometimes fail INP, especially pages with heavy client side frameworks, chat widgets or tag managers loading many scripts. Long tasks over 50 milliseconds on the main thread are the usual suspect, and the Long Animation Frames API in Chrome can help show which scripts are responsible.
Field data needs traffic
CrUX only reports pages and sites with enough real Chrome visits to be statistically useful. Smaller sites often see no data for individual URLs, only an origin wide value or nothing at all. In that case a lightweight real user monitoring script, such as Google's open source web vitals library, can record the same metrics from your own visitors.
How much it matters for search
Google says Core Web Vitals are used by its ranking systems as part of page experience, but it also says good scores don't guarantee top rankings and that relevant, helpful content matters more. The stronger business case is usually conversion. Slow, jumpy pages lose visitors before they read, sign up or buy, whatever their rank.
Putting it on a dashboard
A weekly view of Core Web Vitals for each site, sitting next to uptime and traffic, makes it easier to tell whether a release slowed things down. CrUX aggregates field data over a rolling 28-day window, so changes show up gradually. Track the trend instead of individual days.
A short weekly routine
Each week, check three things for each important site. First, look at the Core Web Vitals report in Search Console for any URL groups that moved from good to needs improvement. Second, compare the 75th percentile values for mobile against last month. Third, match any change against the release log, a new plugin or a new third party script. Most regressions trace back to one recent change, and finding it early is far cheaper than a full performance project later.
Keep lab tests for diagnosis. When the field data slips, run Lighthouse or the performance panel in Chrome DevTools on the affected template, fix the largest cause, and then wait for the 28 day field window to confirm the result. A slow field result is a different signal from a failed health check, which online, degraded, and offline separates from response time on the tile.
Sources
- Google, web.dev, "Web Vitals": https://web.dev/articles/vitals
- web.dev, "Largest Contentful Paint": https://web.dev/articles/lcp
- web.dev, "Interaction to Next Paint": https://web.dev/articles/inp
- web.dev, "Cumulative Layout Shift": https://web.dev/articles/cls
- Chrome for Developers, Chrome UX Report: https://developer.chrome.com/docs/crux
- Google Search Central, "Understanding Core Web Vitals and Google search results": https://developers.google.com/search/docs/appearance/core-web-vitals
- web.dev, "Optimize Largest Contentful Paint" (LCP subparts): https://web.dev/articles/optimize-lcp
- web.dev, "Defining the Core Web Vitals metrics thresholds": https://web.dev/articles/defining-core-web-vitals-thresholds
- GoogleChrome, web-vitals JavaScript library: https://github.com/GoogleChrome/web-vitals