Skip to content
Faisal Mahmud TusherDigital marketing, SEO & analytics
with Faisal Tusher

SEO › Technical SEO

Measuring and Fixing Core Web Vitals

Core Web Vitals explained: what LCP, INP and CLS measure, field versus lab data, how Google uses them, and how to diagnose and fix each one.
Guideintermediate8 min readUpdated

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 (GSC) 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 (CVR) 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

MetricField tool (status)Lab tool (cause)Usual causes
LCPSearch Console CWV report; PageSpeed Insights field dataLighthouse, browser performance panel, PageSpeed labSlow 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
INPSamePerformance panel with interaction recording; long-task profilingLong JavaScript tasks on the main thread; heavy event handlers; third-party scripts; layout work triggered by interactions
CLSSameLighthouse and performance panel layout-shift recordsImages 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 preload hint 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 width and height (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-display set deliberately, fonts preloaded, fallback fonts matched in size).
  • Never insert content above existing content after load, except in response to a user action.
Illustrative example — not a real result

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.

Frequently asked questions

Are Core Web Vitals a ranking factor?

Google documents page experience, of which Core Web Vitals are a part, as a factor in ranking, and also states that great content with weaker page experience still ranks ahead of poor content with excellent page experience. In practice the effect is a tie-breaker among comparable pages, and the larger business effect is on conversion.

Which data does Google use: field or lab?

Field data — real Chrome users' measurements collected in the Chrome User Experience Report — is what the Search Console report and the ranking signal use. Lab tools such as Lighthouse simulate a load and are for diagnosis, not assessment.

Why does my lab score pass but the field data fails?

Lab tests run one device, one network, one page state. Field data covers every real visitor: slow phones, poor networks, pages visited after interactions. A page can look fast in the lab and be slow for the 75th percentile of actual users.

Terms used on this page

Tools to try

Frameworks

Where this page is used

Part of these learning paths

Also related

Sources

  1. Web Vitals — web.dev (Google)
  2. Understanding Core Web Vitals and Google search results — Google Search Central
  3. Core Web Vitals report — Google Search Console Help

Related