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.
| Metric | What it measures | Good | Needs improvement | Poor |
|---|---|---|---|---|
| LCP (Largest Contentful Paint) | Time until the largest image or text block in the viewport is rendered | ≤ 2.5 s | 2.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 ms | 200–500 ms | > 500 ms |
| CLS (Cumulative Layout Shift) | How much visible content moves unexpectedly while the page is in use | ≤ 0.1 | 0.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-vitalsJavaScript 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. Addfetchpriority="high", and never applyloading="lazy"to it. - Optimise images. Serve AVIF or WebP, size images to their display dimensions and use
srcsetandsizesso 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: swaporoptionalso 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 asetTimeoutfallback. - 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
widthandheightattributes, or a CSSaspect-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-adjustdescriptor, so the swap to the web font does not reflow paragraphs. - Animate with transforms. Use
transformandopacityinstead of changingtop,heightormargin. - 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
fetchpriorityautomatically, 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
| Fix | Main metric | Impact | Effort |
|---|---|---|---|
| Prioritise the LCP image (fetchpriority, no lazy load) | LCP | High | Low |
| Width and height on images and embeds | CLS | High | Low |
| Image compression and modern formats | LCP | High | Low to medium |
| Page caching and CDN | LCP | High | Medium |
| Removing or delaying third-party scripts | INP | High | Medium |
| Font preloading and fallback matching | LCP, CLS | Medium | Low to medium |
| Code splitting and breaking up long tasks | INP | High | High |
| Replacing a heavy theme or page builder | All | High | High |
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-displayvalue. - 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.



