Skip to content
London Istanbul · Erzurum
SEO & Performance

Core Web Vitals Explained: A Practical Guide to Improving Website Speed in 2026

Core Web Vitals explained: LCP, INP and CLS thresholds, how to measure them and a prioritised plan to improve website speed and page speed SEO in 2026.

  • 8 min read
  • Atazen Technology

Core Web Vitals are three metrics Google uses to measure real-world user experience: 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, at the 75th percentile of real visits, LCP is 2.5 seconds or less, INP is 200 milliseconds or less and CLS is 0.1 or less. This guide explains what each metric means, how to measure it properly and which fixes improve website speed fastest.

What Core Web Vitals measure and the current thresholds

Each metric answers a simple question a visitor would ask. Has the main content appeared? Does the page react when I tap? Is the layout staying still while I read? Google publishes the thresholds on web.dev, and they are assessed separately for mobile and desktop.

MetricWhat it measuresGoodNeeds improvementPoor
LCP (Largest Contentful Paint)Time until the largest image or text block in the viewport is rendered≤ 2.5 s2.5–4.0 s> 4.0 s
INP (Interaction to Next Paint)Delay between a click, tap or key press and the next visual update, across the whole visit≤ 200 ms200–500 ms> 500 ms
CLS (Cumulative Layout Shift)How much visible content moves unexpectedly while the page is in use≤ 0.10.1–0.25> 0.25

INP replaced First Input Delay (FID) as a Core Web Vital in March 2024. FID only measured the delay before the first interaction was handled; INP looks at the responsiveness of interactions throughout the visit, so it is a much stricter test of heavy JavaScript.

Do Core Web Vitals affect SEO?

Yes, but proportionately. Google's Search Central documentation says Core Web Vitals are used by its ranking systems and recommends achieving good scores, while making clear that relevance and content quality still come first. Think of page speed SEO as a tie-breaker and a conversion lever: a fast page will not rescue thin content, but a slow one wastes the traffic you have earned.

Field data vs lab data: CrUX and Lighthouse

The most common source of confusion is seeing two different sets of numbers for the same page. They come from two different kinds of measurement.

  • Field data (CrUX). The Chrome User Experience Report collects anonymised measurements from real Chrome users over a rolling 28-day window. This is what Google uses when assessing your page experience. Low-traffic pages may not have enough data, in which case Google groups them with similar URLs or the whole origin.
  • Lab data (Lighthouse). Lighthouse loads the page once on a simulated device and network. It is repeatable and great for debugging, but it does not click anything, so it cannot measure INP. It reports Total Blocking Time (TBT) instead, which is a useful lab proxy for responsiveness.

The PageSpeed Insights performance score out of 100 is a Lighthouse lab score. Raising it is helpful, yet the pass or fail that matters for search is the field assessment shown at the top of the same report. If the two disagree, trust the field data and use the lab data to find out why.

Tools to measure Core Web Vitals

  • PageSpeed Insights: field data from CrUX plus a Lighthouse audit for any public URL. The best starting point.
  • Google Search Console, Core Web Vitals report: groups your URLs by status so you can see which templates fail, not just individual pages.
  • Chrome DevTools, Performance panel: records a real session on your machine, highlights the LCP element, long tasks and layout shifts, and shows live INP as you interact.
  • Lighthouse in DevTools or CI: repeatable lab tests for catching regressions before release.
  • Real user monitoring (RUM): the open-source web-vitals JavaScript library lets you send LCP, INP and CLS from your own visitors to your analytics, with attribution data that points to the slow element or script.

How to improve LCP, INP and CLS

Work on one metric at a time and re-test after each change. The fixes below are grouped by the metric they help most, starting with loading speed, which is where most sites have the biggest gap.

Improving LCP

LCP is usually an image or a large heading. Break the time into four parts: server response (TTFB), the delay before the browser discovers the LCP resource, the time to download it and the time to render it. Then fix the biggest part first.

  • Speed up the server. Use full-page caching, a modern PHP or Node runtime and a CDN close to your visitors. As a rough guide, web.dev suggests most sites aim for a TTFB of 0.8 seconds or less.
  • Make the LCP image discoverable. Put it in the HTML as a normal <img>, not a CSS background or a JavaScript-injected element. Add fetchpriority="high", and never apply loading="lazy" to it.
  • Optimise images. Serve AVIF or WebP, size images to their display dimensions and use srcset and sizes so phones do not download desktop images.
  • Remove render-blocking resources. Inline the small amount of critical CSS, defer non-essential scripts and avoid loading large frameworks before the first paint.
  • Handle web fonts carefully. If the LCP element is text, preload the main font file, self-host it and use font-display: swap or optional so text is not hidden while fonts load.

Improving INP

Poor INP almost always means the main thread is busy running JavaScript when the visitor tries to interact. Any task longer than 50 milliseconds is considered a long task and can delay a response.

  • Ship less JavaScript. Use code splitting so each page loads only what it needs, and remove unused libraries and polyfills.
  • Break up long tasks. Split heavy work into smaller chunks and yield back to the browser between them, for example with scheduler.yield() where supported or a setTimeout fallback.
  • Keep event handlers light. Update the UI first, then do analytics calls, storage or network work afterwards.
  • Audit third-party scripts. Chat widgets, tag managers, A/B testing tools and ad scripts are frequent culprits. Load them after interaction or remove the ones nobody uses.
  • Reduce DOM size and rendering cost. Very large pages make every update slower; paginate long lists and avoid layout-heavy animations.

Improving CLS

  • Always set dimensions. Give images and videos width and height attributes, or a CSS aspect-ratio, so the browser reserves space before they load.
  • Reserve space for ads, embeds and banners. Cookie notices, promotional bars and iframes should have a fixed slot rather than pushing content down.
  • Do not insert content above existing content unless it is a response to a user action.
  • Stabilise fonts. Choose fallback fonts with similar metrics, or use the size-adjust descriptor, so the swap to the web font does not reflow paragraphs.
  • Animate with transforms. Use transform and opacity instead of changing top, height or margin.
  • Keep pages eligible for the back/forward cache. Instant back navigation avoids reloads and the shifts that come with them.

Caching, CDN and other site-wide wins

Some improvements help all three metrics at once. Serve static assets with long Cache-Control lifetimes and hashed filenames, so repeat visitors load almost nothing. Put a CDN in front of the site to cut latency for international audiences, which matters if you serve customers in both the UK and Turkey. Enable Brotli or gzip compression and HTTP/2 or HTTP/3, and keep redirect chains to a minimum.

WordPress-specific tips

WordPress can pass Core Web Vitals comfortably, but plugins and page builders make it easy to slide backwards. If you are weighing up the platform itself, our guide to WordPress for business covers the trade-offs.

  • Use a reputable caching plugin or server-level page cache, plus an object cache such as Redis on busier sites.
  • Run a supported PHP version and quality hosting; cheap shared hosting is often the main cause of slow TTFB.
  • Recent WordPress versions add lazy loading and fetchpriority automatically, but check that your theme or slider does not override this for the hero image.
  • Audit plugins regularly. Each one may load its own CSS and JavaScript on every page, even where it is not used.
  • Prefer a lightweight block theme over a heavy page builder for new builds.
  • Convert the media library to WebP or AVIF and limit the image sizes the theme generates.

Priority table: impact vs effort

FixMain metricImpactEffort
Prioritise the LCP image (fetchpriority, no lazy load)LCPHighLow
Width and height on images and embedsCLSHighLow
Image compression and modern formatsLCPHighLow to medium
Page caching and CDNLCPHighMedium
Removing or delaying third-party scriptsINPHighMedium
Font preloading and fallback matchingLCP, CLSMediumLow to medium
Code splitting and breaking up long tasksINPHighHigh
Replacing a heavy theme or page builderAllHighHigh

Start in the top rows. Low-effort fixes often move a page from "needs improvement" to "good" within one CrUX cycle, which is roughly four weeks because of the 28-day window.

Core Web Vitals checklist

  • Check field data in PageSpeed Insights and Search Console for mobile first.
  • Identify the LCP element on each key template.
  • Confirm the LCP image is in the HTML, prioritised and not lazy loaded.
  • Serve correctly sized AVIF or WebP images with srcset.
  • Set dimensions on every image, video, iframe and ad slot.
  • Preload and self-host critical fonts with a sensible font-display value.
  • Defer non-critical JavaScript and review every third-party tag.
  • Look for long tasks in the DevTools Performance panel during real interactions.
  • Enable page caching, compression and a CDN.
  • Add real user monitoring so regressions are visible before they reach CrUX.

How Atazen helps

Performance is part of how we build, not a plug-in added at the end. Our web development and WordPress teams audit field and lab data, fix the templates that fail and set up monitoring so scores stay green after launch. If speed work is part of a wider redesign, our website cost guide explains how to budget for it. To get a clear view of where your site stands, contact us for a performance review.

CategorySEO & Performance Published ByAtazen Technology
FAQ

Questions on this topic

What are good Core Web Vitals scores?

A page has good Core Web Vitals when LCP is 2.5 seconds or less, INP is 200 milliseconds or less and CLS is 0.1 or less, measured at the 75th percentile of real visits. Google assesses mobile and desktop separately, so a page can pass on desktop and still fail on mobile, which is usually the harder target.

Why is my PageSpeed Insights score different from my Core Web Vitals result?

The score out of 100 comes from a single Lighthouse lab test on a simulated device, while the Core Web Vitals assessment uses field data from real Chrome users over 28 days. Lab tests cannot measure INP and may not reflect your real visitors' devices or networks. Use field data to judge success and lab data to diagnose problems.

How long does it take for Core Web Vitals improvements to show?

Lab results change immediately after you deploy a fix. Field data in PageSpeed Insights and Search Console is based on a rolling 28-day window, so improvements usually appear gradually over about four weeks. Search Console also lets you validate a fix, which starts its own monitoring period for the affected group of URLs.

Can a WordPress site pass Core Web Vitals?

Yes. WordPress sites pass regularly when they use good hosting, page caching, optimised images and a lightweight theme. Problems usually come from heavy page builders, too many plugins loading scripts on every page and unoptimised hero images. Auditing plugins and fixing the LCP image are typically the quickest wins.

Is INP harder to fix than LCP?

Often, yes. LCP issues usually have clear causes such as large images or slow servers, and quick fixes exist. INP depends on how much JavaScript runs on the main thread during interactions, so fixing it can mean removing third-party scripts, splitting code or restructuring event handlers, which takes more development time.

Ready to build something extraordinary?

Start a Project