The three metrics
Largest Contentful Paint (LCP) measures loading: the time from navigation start until the largest image or text block in the viewport has rendered. Good is 2.5 seconds or less; poor is over 4 seconds. LCP is dominated by the hero image, a large heading, or a block of text, so the fix is usually about that one element: how quickly its bytes arrive and how early the browser knows to fetch them.
Interaction to Next Paint (INP) measures responsiveness: the latency of interactions (clicks, taps, key presses) across the page's whole lifetime, reported as a high percentile of all interactions. Good is 200 milliseconds or less; poor is over 500 milliseconds. INP replaced First Input Delay as a Core Web Vital in March 2024; the difference is that INP measures every interaction, not just the first, and the full time until the next frame paints, not just input delay. Long JavaScript tasks are the usual cause.
Cumulative Layout Shift (CLS) measures visual stability: the sum of unexpected movements of visible elements during the page's lifetime, weighted by how much of the viewport moved and how far. Good is 0.1 or less; poor is over 0.25. Shifts come from images without dimensions, late-loading fonts, injected banners and ads, and content inserted above what the user is reading.
The thresholds and definitions above are Google's documented ones at the time of writing; they have changed before (FID to INP) and the sources listed on this page are where changes appear.
How the assessment works
Two properties of the assessment explain most confusion:
- Field data, not lab data. The signal and the Search Console report use the Chrome User Experience Report (CrUX): measurements from real Chrome users who opted in, aggregated per URL and per origin over the previous 28 days. Lighthouse, PageSpeed Insights' lab section and similar tools simulate a load on one device and are useful for finding causes, not for knowing the status.
- The 75th percentile. A page passes a metric when three quarters of its real page loads meet the "good" threshold. A fast median is not enough; the slow quarter — older phones, poor connections — decides.
Search Console's Core Web Vitals report (GSCGoogle's search performance and indexing tool.) groups URLs by status and by the template pattern that shares the problem, which is the clue that fixes belong at the template level. URLs with too little traffic have no field data and are not assessed individually; Google documents that it may fall back to origin-level data in that case.
What the metrics mean for SEO and for the business
Google's documentation says two things at once: page experience, including Core Web Vitals, is used in ranking; and content relevance matters more, so a page with excellent content and poor vitals generally outranks a page with the reverse. The practical reading is that vitals are a tie-breaker among pages competing on similar content, and a differentiator in crowded commercial results where everyone's content is comparable.
The larger effect is on behaviour after the click. A page that takes four seconds to show its main content loses visitors before it loads; a page that shifts as someone reaches for a button produces mis-taps and abandoned forms. Conversion rate (CVRShare of visits or clicks that convert.) is where vitals improvements usually pay for themselves, which is also why the work is easier to fund when it is framed that way.
Diagnosing each metric
| Metric | Field tool (status) | Lab tool (cause) | Usual causes |
|---|---|---|---|
| LCP | Search Console CWV report; PageSpeed Insights field data | Lighthouse, browser performance panel, PageSpeed lab | Slow server response; render-blocking CSS and scripts; the LCP image lazy-loaded, unsized or large; late discovery of the LCP resource; client-side rendering of the main content |
| INP | Same | Performance panel with interaction recording; long-task profiling | Long JavaScript tasks on the main thread; heavy event handlers; third-party scripts; layout work triggered by interactions |
| CLS | Same | Lighthouse and performance panel layout-shift records | Images and embeds without width and height; web fonts swapping late; banners, cookie notices and ads injected above content; content loaded above existing content |
The method: read the status by template in Search Console, pick the template with the most traffic and the worst metric, reproduce the problem in the lab on a representative slow device, find the element or script responsible, fix it in the template, and confirm in the field data after the 28-day window.
Core Web Vitals classifier
Fixes that move many pages
Because the metrics are assessed per URL but caused per template, the high-return fixes are structural.
For LCP
- Reduce server response time (caching, a CDN, fewer blocking back-end calls).
- Make the LCP element discoverable early: an image in the initial HTML with a
preloadhint if it is critical, never lazy-loaded; text that does not wait for a web font to arrive before showing. - Serve images at the size displayed, in a modern format, responsive to viewport — the image SEO guide covers delivery.
- Remove or defer render-blocking CSS and JavaScript; inline the critical CSS for above-the-fold content.
- Avoid client-side rendering of the main content; the JavaScript SEO guide covers rendering strategies.
For INP
- Break long tasks into smaller ones so the browser can paint between them.
- Defer non-essential scripts; load third-party tags after interaction or on idle.
- Keep event handlers light; move heavy work off the main thread (web workers) where possible.
- Audit tag managers and analytics: the scripts a marketing team adds are a frequent INP cause.
For CLS
- Set explicit
widthandheight(or CSS aspect ratio) on every image, video and embed. - Reserve space for ads, banners and dynamically loaded blocks.
- Load web fonts with a strategy that avoids late swaps (
font-displayset deliberately, fonts preloaded, fallback fonts matched in size). - Never insert content above existing content after load, except in response to a user action.
A retailer's product template
Search Console shows the product-page template failing LCP on mobile while category and content pages pass. Lab profiling of one product page on a throttled mobile profile finds the hero image is lazy-loaded, served at desktop size and discovered only after a script runs. The template fix: the first product image loads eagerly with a preload hint and responsive sizes; the carousel script that previously inserted it is deferred. CLS on the same template comes from a "recently viewed" strip injected above the price after load; reserving its height removes the shift. Both changes touch one template and improve every product page; the field data updates over the following weeks.
Third-party scripts
Analytics, tag managers, consent banners, chat widgets, ad tags, personalisation, A/B testing scripts and embedded media are, on many sites, the main cause of poor interaction responsiveness and a frequent cause of layout shift. The approach: inventory every third-party script with its owner and purpose; remove the ones nobody can justify; load the rest after the page is interactive, or on interaction, where their function allows; reserve space for anything that injects into the layout (consent banners, embeds); and measure the field metrics before and after each removal. The tag manager is a convenience for marketing and a risk for performance, and its container needs the same review as the codebase.
Prioritising across templates
Field data is reported by URL groups that usually correspond to templates. The prioritisation is by pages affected and value: a product template failing on mobile outranks a blog template failing on desktop, and a single fix to a template moves every page it renders. Work through the groups in order of affected traffic, fix the metric that fails in each, and verify in the field data over the following weeks rather than in a lab run the next day.
Measuring over time
Vitals belong on the technical dashboard beside crawl and indexing metrics, read from the field: the share of URLs in each status per template, the 75th-percentile value per metric, and the trend after releases. A release that regresses INP or CLS is visible within weeks; catching it needs the metrics to be watched, which the SEO KPIs guide covers. Lab checks in the deployment pipeline (performance budgets per template) catch most regressions before they reach users.
When the report flags one URL group for a slow largest contentful paint, the troubleshooting page on fixing an LCP that is too slow isolates the element and the slow loading phase.
When a URL group fails visual stability, the troubleshooting page on fixing a layout shift issue finds the element that moves and the template that let it.
When a URL group fails responsiveness, the page on fixing slow interactions records the slow tap and splits it into input delay, processing and presentation.
The page speed impact experiment shows how to value Core Web Vitals work in conversions rather than scores, by comparing an optimised build with the current one in a server-side split.
Core Web Vitals answer only one of the questions in Google's page experience guidance; the guide to page experience beyond Core Web Vitals covers secure connections, mobile display, intrusive interstitials and ads that interfere with the main content.
Common mistakes
- Optimising the lab score. The field data is the assessment; the lab is for diagnosis.
- Fixing pages instead of templates. A hundred pages fixed by hand; the template still generates the problem.
- Lazy-loading the hero image. The most common self-inflicted LCP failure.
- Images without dimensions. The most common CLS cause, and the cheapest fix.
- Adding scripts without measuring. Each tag is small; together they are the INP problem.
- Expecting ranking jumps. Vitals are a tie-breaker in ranking and a lever for conversion; set expectations accordingly.
The technical SEO audit tutorial includes vitals as one of its checks; the author's technical SEO page describes how page-experience work is prioritised in practice.
