Core Web Vitals are three measurements Google uses to judge how a page feels to real visitors: Largest Contentful Paint (LCP) for loading, Interaction to Next Paint (INP) for responsiveness and Cumulative Layout Shift (CLS) for visual stability. A page passes when LCP is 2.5 seconds or less, INP is 200 milliseconds or less and CLS is 0.1 or less, each measured at the 75th percentile of real visits.
Below: what each metric measures, why your numbers differ from tool to tool, the usual causes of a bad score and the fix for each.
The three metrics and their thresholds
| Metric | What it measures | Good | Needs improvement | Poor |
|---|---|---|---|---|
| LCP | Time until the largest image or text block in the first screen is drawn | ≤ 2.5 s | 2.5 - 4.0 s | > 4.0 s |
| INP | Delay between a click, tap or key press and the next visual update | ≤ 200 ms | 200 - 500 ms | > 500 ms |
| CLS | How much visible content moves unexpectedly (a score, not a time) | ≤ 0.1 | 0.1 - 0.25 | > 0.25 |
INP replaced First Input Delay (FID) as a Core Web Vital in March 2024. FID only timed the first interaction on a page. INP looks at all of them.
Lab data, field data and the 75th percentile
Two different kinds of numbers go by the same names, and mixing them up causes most of the confusion.
- Field data comes from real Chrome users on their own devices and networks, collected in the Chrome UX Report (CrUX) over a rolling 28 days. This is what Google assesses. It only exists for pages and sites with enough traffic. A low-traffic page falls back to the figure for the whole site, or has no data at all.
- Lab data is one simulated page load in a controlled environment, usually Lighthouse. It works on any page, it's repeatable, and it's the right tool for debugging. But it's one device on one connection, with no real user. Nobody clicks anything in a standard lab test, so it doesn't report INP. Total Blocking Time (TBT) is the closest stand-in.
Field results are reported at the 75th percentile: the value that 75% of visits were at or better than. If your LCP is 2.4 seconds at the 75th percentile, three out of four visits saw the main content within 2.4 seconds. Mobile and desktop are assessed separately, and mobile is usually the worse of the two.
The 28-day window also explains why a fix takes time to show. A change shipped today moves the field figure a little each day for four weeks.
LCP: Largest Contentful Paint
LCP marks the moment the biggest element in the first screen is rendered. That's usually a hero image, a video poster or a headline block.
Common causes of a slow LCP
- Slow server response. Nothing can be drawn until the HTML arrives. See what a good response time looks like.
- Render-blocking CSS and JavaScript in the
<head>. - The LCP image is found late: it's a CSS background, it's inserted by JavaScript, or it's lazy-loaded.
- The image is too heavy: far larger than it's displayed, in an old format, or barely compressed.
- Client-side rendering: the content only exists after a JavaScript bundle has downloaded and run.
Fixes
- Cache pages and serve them through a CDN to cut server time.
- Put the hero image in the HTML as a normal image, never lazy-load it, and tell the browser it matters:
<img src="/img/hero.webp" width="1200" height="600" alt="Our workshop" fetchpriority="high">
- Serve WebP or AVIF, sized for the screen with
srcset. The Responsive Image Checker lists what each image is missing, and the Lazy Loading Checker flags a lazy-loaded first image. - Inline the CSS needed for the first screen and add
deferto scripts that aren't needed for the first paint. - Compress text responses with gzip or Brotli. The Gzip Checker confirms it's on.
INP: Interaction to Next Paint
For every click, tap and key press, the browser measures the time from the input to the next frame it paints. INP reports the slowest of those interactions during the visit (on very busy pages a rare outlier is ignored). Scrolling and hovering don't count. Unlike LCP, it covers the whole time the page is open, not only the load.
Common causes of a slow INP
- Long JavaScript tasks. The browser can't react to a tap while it's busy running a script. Any task over 50 milliseconds counts as long.
- Third-party scripts: tag managers, chat widgets, ads, analytics and A/B testing tools.
- Heavy event handlers that do all their work before the screen is allowed to update.
- A very large DOM. Every update costs more to style and lay out.
- Hydration in JavaScript frameworks. The page looks ready but is still busy wiring itself up.
Fixes
- Remove scripts you don't need and load the rest with
defer, or after the page has become interactive. - Break long tasks into smaller pieces and give control back to the browser between them (
setTimeout, orscheduler.yield()where it's supported). - Show feedback first (open the menu, show a spinner), then do the expensive work.
- Keep the DOM small: paginate or virtualise long lists.
- Move heavy calculations to a web worker.
CLS: Cumulative Layout Shift
CLS scores how much visible content jumps around without the visitor causing it: the paragraph that drops down when an ad loads, the button that moves just as you tap it. Each shift is scored by how much of the screen moved and how far. CLS reports the worst burst of shifts during the visit. Shifts within half a second of the visitor's own click or tap are left out.
Common causes of a high CLS
- Images, videos and iframes without dimensions. The browser can't reserve space for them.
- Ads, embeds and banners injected without reserved space, including cookie notices and promo bars that push the page down.
- Web fonts that swap in at a different size from the fallback font.
- Content inserted above existing content after the page has loaded.
- Animations that change layout properties such as
top,heightormargin.
Fixes
- Give every image and video
widthandheightattributes, and reserve space for anything that loads late:.ad-slot { min-height: 250px; } .video-embed { aspect-ratio: 16 / 9; width: 100%; } - Overlay cookie banners and notices instead of pushing the content down.
- Preload the main font and use
font-display: optional, or match the fallback font's metrics withsize-adjust. - Animate with
transformandopacity, which don't move other elements.
How to measure Core Web Vitals
| Tool | Data | Use it for |
|---|---|---|
| PageSpeed Insights | Field data at the top (for the URL and for the whole site), a Lighthouse lab run below | A quick pass or fail verdict plus diagnostics |
| Chrome DevTools | Your own session: the Performance panel shows LCP, CLS and INP live as you use the page, and the Lighthouse panel runs a lab audit | Finding the LCP element and the script behind a slow interaction |
| Search Console | Field data, with your URLs grouped into good, needs improvement and poor | The whole-site picture and tracking a fix |
| Upmonora Core Web Vitals Checker | Field LCP, INP and CLS when Google has data, a lab run on mobile or desktop, and a review of the page itself | A free check of any URL that also points at likely causes: server response time, render-blocking files, images without dimensions, heavy JavaScript |
A workable routine: use field data to find which metric fails and on which pages, use lab tools to find why, fix it, confirm in the lab straight away, then watch the field figure over the following 28 days. For pages with too little traffic for Google's data, Google's open-source web-vitals JavaScript library can send the same measurements to your own analytics.
Do Core Web Vitals affect rankings?
Yes, a little. Google says its ranking systems use Core Web Vitals as part of page experience. What counts is the field data from real users, not the 0 to 100 Lighthouse score. Google also says good scores don't guarantee good rankings: relevance and useful content come first.
A realistic way to think about it: Core Web Vitals act as a tie-breaker between pages that are otherwise similar. They won't lift a thin page above a better one, and once all three are in the good range there's little SEO reason to chase perfect numbers. The stronger argument is the visitor. A page that appears quickly, responds at once and doesn't jump around loses fewer people before they read or buy anything.
One part of LCP can change from hour to hour without a deploy: server response time. A slow database or a busy server pushes LCP up for every visitor until someone notices. Upmonora's website monitoring records response time on every check and flags a site that gets slower than its own baseline.
To see where a page stands today, run it through the free Core Web Vitals Checker. No sign-up is needed.
Frequently asked questions
What are Core Web Vitals?
Three metrics Google uses to describe how a page feels to real visitors: Largest Contentful Paint (loading), Interaction to Next Paint (responsiveness) and Cumulative Layout Shift (visual stability).
What is a good Core Web Vitals score?
LCP of 2.5 seconds or less, INP of 200 milliseconds or less and CLS of 0.1 or less, each measured at the 75th percentile of real visits. A page passes when all three are in the good range.
Are Core Web Vitals a ranking factor?
Yes, Google's ranking systems use them, but relevance and content quality matter far more. Good scores do not guarantee high rankings; they mostly help when competing pages are otherwise similar.
Why is my PageSpeed score different from my Core Web Vitals?
The 0 to 100 performance score comes from one simulated lab test. Core Web Vitals come from real Chrome users over the previous 28 days. A page can score low in the lab and still pass in the field, or the other way round.