Core Web Vitals turned page speed from a vague goal into three numbers with pass marks. That made them easy to report and easy to misread: a perfect Lighthouse score that fails in the field, a page judged on data from the whole site, a fix that takes a month to show.
This guide explains what each metric measures, how Google collects and judges them, how much they matter for SEO, and how to improve them across a site. Each metric has its own detailed guide.
What are Core Web Vitals?
Core Web Vitals are three metrics that measure real users’ experience of a page: how quickly the main content loads, how quickly the page responds to input, and how stable the layout is. Google describes them as “a set of metrics that measure real-world user experience for loading performance, interactivity, and visual stability of the page” (Core Web Vitals in Search).
| Metric | Measures | Good | Needs improvement | Poor | Guide |
|---|---|---|---|---|---|
| Largest Contentful Paint (LCP) | Loading: when the main content appears | ≤ 2.5 s | 2.5–4 s | > 4 s | LCP |
| Interaction to Next Paint (INP) | Responsiveness: delay after clicks, taps and key presses | ≤ 200 ms | 200–500 ms | > 500 ms | INP |
| Cumulative Layout Shift (CLS) | Visual stability: how much content jumps around | ≤ 0.1 | 0.1–0.25 | > 0.25 | CLS |
Thresholds are from web.dev and the metric pages linked there. INP replaced First Input Delay on March 12, 2024; FID only measured the first interaction, while INP covers every click, tap and key press in a visit.
Two supporting metrics come up constantly: Time to First Byte (TTFB), which isn’t a Core Web Vital but sits underneath every loading metric (see TTFB), and Total Blocking Time (TBT), the lab metric used as a stand-in for INP.
How are Core Web Vitals measured?
Google judges Core Web Vitals on field data: measurements from real Chrome users, collected in the Chrome UX Report (CrUX). Three details decide what the numbers mean:
- The 75th percentile. web.dev recommends measuring “the 75th percentile of page loads, segmented across mobile and desktop devices.” A page passes LCP when at least 75% of visits load the main content within 2.5 s, not when the average does.
- A rolling 28 days. CrUX data covers the previous 28 days, so changes show gradually.
- URL or origin. A URL needs enough Chrome traffic to have its own data. Without it, tools fall back to origin data for the whole site, or show none.
Lab data comes from a single simulated load, usually Lighthouse. It’s reproducible and full of diagnostics, but it isn’t what Google judges, and it can’t measure INP at all, because there’s no real user interacting. Use field data to decide whether there’s a problem and lab data to find why. The Core Web Vitals audit guide covers the difference in detail.
Do Core Web Vitals affect SEO?
Yes, modestly. Google’s page experience documentation says “Core Web Vitals are used by our ranking systems”, and that there’s “no single signal”: core ranking systems “look at a variety of signals that align with overall page experience.”
The important caveat is in the same document: “Google Search always seeks to show the most relevant content, even if the page experience is sub-par.” Good Core Web Vitals won’t lift a page that doesn’t answer the query, and poor ones rarely sink a page that’s clearly the best answer. Where they matter most is between pages of similar relevance, and for users: slow, jumpy pages lose visitors whatever their rank.
Two more details from Google: page experience is generally evaluated “on a page-specific basis”, though “we do have some site-wide assessments”; and Google recommends “site owners achieve good Core Web Vitals for success with Search and to ensure a great user experience generally.”
How do you improve each metric?
LCP: make the main content arrive sooner
web.dev’s LCP optimisation guide splits LCP into four parts: time to first byte, resource load delay, resource load duration and element render delay. Most slow LCPs come from a hero image the browser discovers late, a lazy-loaded LCP image, an oversized image, render-blocking CSS and JavaScript, or a slow server. Details in how to improve LCP and the image optimization workflow for responsive sizes, loading priority and reserved image space.
If the main content waits for styles or synchronous scripts, the render-blocking resources guide isolates the critical rendering path and the tradeoffs of deferring code.
INP: keep the main thread free to respond
Every interaction has an input delay, a processing duration and a presentation delay. Long JavaScript tasks, heavy third-party scripts, large DOMs and client-side rendering are the usual causes. Because INP needs real interactions, start from field data and reproduce in the lab. Details in how to improve INP and the third-party script audit for analytics tags, chat widgets and embeds.
Your own application code can be the bottleneck too. Use the first-party JavaScript performance guide to trace startup work, hydration and slow interaction handlers before changing a bundle.
For interaction-level evidence, the Long Animation Frames and INP guide connects slow clicks to script, style and layout work without treating every long frame as an INP failure.
CLS: reserve space for everything
Images without dimensions, ads and embeds without reserved space, content injected above what’s already visible, and web fonts are web.dev’s list of common causes. CLS is measured over the whole visit, so lab tools often report less than users experience. Details in how to fix CLS.
If a font swap shifts text or a font request delays the largest heading, follow the font loading and Core Web Vitals guide to measure the impact before changing preload or display settings.
For movement caused by transitions or animations, the CSS animation and layout shift guide shows how to trace the shifting element and choose a stable motion pattern.
TTFB: fix the server first
A slow first byte delays everything else. Hosting, caching, a CDN and fewer redirects are the main levers. Details in how to reduce TTFB.
How do you measure Core Web Vitals across a whole site?
Search Console’s Core Web Vitals report (help) shows field data from CrUX, separately for mobile and desktop, grouped into URL groups of similar pages. A group’s status is its poorest metric, and groups without enough data don’t appear. It tells you which templates fail, not which individual URLs.
PageSpeed Insights shows field and lab data for one URL at a time. For a quick real-user check without a lab run, the free Core Web Vitals checker shows a URL’s CrUX data for mobile or desktop and whether it passes.
Crawlens combines both, joined to the crawl:
- Measure Core Web Vitals runs PageSpeed Insights tests for your most important pages (the start page, then the indexable pages with the most internal links), on mobile, desktop or both, with your own free API key.
- Real-user data for all pages checks the Chrome UX Report for every indexable page, about 140 pages a minute. Pages with little traffic have no data of their own.
- A 25-week trend shows the whole site’s 75th-percentile values per 28-day period.
- Each URL’s Page speed tab shows its field data (with a note when it’s whole-site data), the Lighthouse score and the biggest opportunities.
The audit then flags pages by real-user data: Poor LCP, Poor INP, Poor CLS and Core Web Vitals need improvement, using mobile data when it was measured, since Google indexes mobile-first. Lab and crawl checks add context: Low Lighthouse performance score, Slow server response (over 1 second), Large HTML (over 2 MB) and Pages PageSpeed Insights could not test. The step-by-step process is in the Core Web Vitals audit guide.
When a page feels slow specifically on phones, use the mobile page speed guide to compare mobile field data with a reproducible lab trace and fix the failing metric first.
Fresh loads are not the whole journey. The back/forward cache and Core Web Vitals guide shows how to test history restores and catch stale state after a visitor presses Back.
What should you fix first?
- Templates, not URLs. Core Web Vitals problems almost always come from a page type: product pages, articles, category listings. Fix the template and every page using it improves.
- Pages that matter. Start with templates that carry the most search traffic or revenue. With Search Console connected, each URL’s details in Crawlens show its clicks (Search tab) next to its vitals (Page speed tab).
- Poor before needs improvement. A metric in the poor range affects a quarter or more of visits badly.
- Mobile first. Mobile is usually worse and is what Google indexes.
- The metric with the clearest cause. An unsized hero image or a render-blocking script is an afternoon’s fix; reworking a JavaScript framework is a project.
How do you know a fix worked?
Lab tests show the effect straight away, so re-test the affected pages to confirm the change is live. Field data takes longer: CrUX is a 28-day rolling window, so the full effect shows about four weeks later. In Search Console, start validation on the fixed issue; Google monitors the URL group for 28 days. In Crawlens, measure again after a crawl and use Compare: pages that moved out of the poor range show up as fixed issues, and the 25-week trend shows the site-wide direction.
Core Web Vitals checklist
- Field data checked for mobile and desktop, at the 75th percentile
- Failing templates identified (Search Console URL groups, or a bulk test)
- LCP within 2.5 s: LCP image discoverable, not lazy-loaded, sized and compressed; no render-blocking resources
- INP of 200 ms or less: long tasks broken up, third-party scripts deferred, DOM kept small
- CLS of 0.1 or less: dimensions on images and embeds, space reserved for ads, fonts handled
- TTFB kept low: caching, CDN, no redirect chains
- High-traffic templates fixed first
- Fixes confirmed in the lab, then in field data after 28 days
All Core Web Vitals guides
- Back/forward cache and Core Web Vitals: test return visitsTest whether back and forward navigation restores your pages, find bfcache blockers, and measure the effect without confusing restores with fresh loads.
- CSS animations and layout shifts: find the CLS culpritFind CSS transitions that move surrounding content, distinguish visual motion from CLS, and replace layout-changing animations with safer patterns.
- First-party JavaScript performance: reduce main-thread workFind expensive code you own, from large startup bundles to slow event handlers, and prioritize fixes using field INP and browser performance traces.
- Font Loading and Core Web Vitals: Diagnose and FixFind out when web fonts delay text or move it after load. Audit FCP, LCP and CLS, then choose the right font files, preload and display strategy.
- Image optimization for Core Web Vitals: improve LCP without causing CLSA practical image workflow for LCP and CLS: right-size responsive images, prioritize the hero, lazy-load lower images and reserve layout space.
- Long Animation Frames and INP: find the work behind slow clicksUse Long Animation Frames data to connect slow interactions with script, rendering and layout work, then verify INP improvements in the field.
- Mobile page speed: diagnose slow pages with field and lab dataUse mobile CrUX field data and PageSpeed Insights lab diagnostics to isolate slow templates, then fix the cause of LCP, INP or CLS.
- Render-blocking resources SEO: fix CSS and scripts delaying LCPFind CSS and JavaScript on the critical rendering path, decide what to inline, defer or keep, and verify the effect on LCP.
- Third-party scripts and Core Web Vitals: find the tags slowing your pagesFind which analytics, chat, ad and embed scripts affect LCP or INP, then remove, defer or load them later without breaking tracking and essential features.
- How to check Core Web Vitals for every page on your sitePageSpeed Insights tests one URL at a time. How to audit LCP, INP and CLS across a whole site with real-user CrUX data, and what to fix first.
- Cumulative Layout Shift (CLS): causes and how to fix themWhat CLS measures and how it's calculated, why lab tools under-report it, the five most common causes of layout shifts, and the fix for each.
- Interaction to Next Paint (INP): how to find and fix slow interactionsWhat INP measures, why it replaced FID, the three phases of every interaction, and how to find and fix the long tasks that make pages slow to respond.
- Largest Contentful Paint (LCP): how to find and fix a slow LCPWhat LCP measures, what counts as good, the four parts every LCP breaks into, and the fixes that move it most: discovery, priority, image size and server speed.
- Time to First Byte (TTFB): what's good and how to reduce itWhat TTFB includes, what a good TTFB is, why it matters though it isn't a Core Web Vital, and how to cut it with hosting, caching, CDNs and fewer redirects.
Frequently asked questions
What are the three Core Web Vitals?
Largest Contentful Paint (LCP) measures loading, Interaction to Next Paint (INP) measures responsiveness, and Cumulative Layout Shift (CLS) measures visual stability. Good scores are LCP within 2.5 seconds, INP of 200 milliseconds or less, and CLS of 0.1 or less.
Are Core Web Vitals a ranking factor?
Yes, Google says Core Web Vitals are used by its ranking systems, as part of page experience. It also says it always seeks to show the most relevant content even if the page experience is sub-par, so they rarely outweigh relevance.
What replaced First Input Delay?
Interaction to Next Paint (INP) replaced First Input Delay (FID) as a Core Web Vital on March 12, 2024. FID measured only the delay of the first interaction; INP looks at all clicks, taps and key presses during a visit.
Why do my Core Web Vitals show data for the whole site instead of my page?
Field data comes from the Chrome UX Report, which needs enough real Chrome visits to a URL. When a page has too little traffic, tools fall back to origin data covering the whole site, or show no field data at all.
How long does it take for Core Web Vitals improvements to show?
Field data is a rolling 28-day window, so a fix shows fully about four weeks after it ships. Search Console's validation for the Core Web Vitals report also monitors for 28 days.