# Core Web Vitals: LCP, INP and CLS Explained, How to Test Them and How to Improve Them (2026)

> Core Web Vitals in 2026: LCP, INP and CLS thresholds, how to run a Core Web Vitals test, and the fixes that improve each one. Free page speed checker.

Canonical: https://abacklaunch.com/blog/core-web-vitals-guide
Last updated: 2026-11-21

By Devvrat Hans, Founder. 10 min read. Published 2026-11-21.

Core Web Vitals are three Google metrics that measure how a page feels to real visitors: Largest Contentful Paint (LCP) for loading, good at 2.5 seconds or less; Interaction to Next Paint (INP) for responsiveness, good at 200 milliseconds or less; and Cumulative Layout Shift (CLS) for visual stability, good at 0.1 or less. Google measures them on real Chrome users and judges a page by its 75th percentile visit. INP replaced First Input Delay (FID) as a Core Web Vital on March 12, 2024.

Most slow startup pages are slow for the same few reasons: a slow server response, heavy pages, render-blocking scripts, oversized images and too much JavaScript. The free [page speed checker](https://abacklaunch.com/tools/page-speed-checker) measures the server and page-weight side of that in a few seconds, and PageSpeed Insights gives you the Core Web Vitals themselves.

This guide explains each metric, how Google collects the data, how to run a Core Web Vitals test properly, and the fixes that improve LCP, INP and CLS, in the order that usually pays off. For a one-paragraph definition, see the [Core Web Vitals glossary entry](https://abacklaunch.com/glossary/core-web-vitals).

## The three Core Web Vitals and their thresholds

| Metric | What it measures | Good | Needs improvement | Poor | |
| LCP (Largest Contentful Paint) | Time until the largest image or text block in the viewport is drawn | 2.5 s or less | Over 2.5 s, up to 4 s | Over 4 s | |
| INP (Interaction to Next Paint) | Delay between a click, tap or key press and the next frame drawn, across the visit | 200 ms or less | Over 200 ms, up to 500 ms | Over 500 ms | |
| CLS (Cumulative Layout Shift) | How much visible content moves unexpectedly while the page is used | 0.1 or less | Over 0.1, up to 0.25 | Over 0.25 | |

A page passes the Core Web Vitals assessment when all three are "good" at the 75th percentile, measured separately for mobile and desktop. In plain terms: at least three in four visits must have a good experience on each metric. These thresholds come from Google's [Web Vitals documentation](https://web.dev/articles/vitals), which says the stable metrics change at most once a year.

### Why INP replaced FID

FID measured only the delay before the browser started handling the first interaction. A page could pass FID and still freeze for a second every time someone opened a menu. INP looks at every interaction during the visit and reports one of the slowest, and it counts the full time until the screen updates. It is a much harder metric to pass, which is why many sites that were "green" on FID went amber in 2024.

## Field data vs lab data

The most common confusion with Core Web Vitals is two numbers that disagree. They come from different places.

| | Field data | Lab data | |
| Source | Real Chrome users (the Chrome UX Report, CrUX) | A simulated load in a test environment (Lighthouse) | |
| Time window | The last 28 days | One run, right now | |
| Measures INP? | Yes | No: there is no user to interact; Total Blocking Time is the stand-in | |
| Used by Google Search | Yes | No | |
| Best for | Knowing where you stand | Debugging a fix before you ship it | |

Field data needs enough Chrome traffic. A new page, or a young site, often has no field data at all; PageSpeed Insights then shows only the lab result, or a figure for the whole origin. That is normal. Use lab data to find problems, and wait for field data to confirm the fix.

## Do Core Web Vitals affect rankings?

Yes, a little. Google says Core Web Vitals are used by its ranking systems as part of page experience, and recommends good scores for success in Search. It also says relevance comes first: a page with the best answer can outrank a faster page with a worse one. Think of Core Web Vitals as a tie-breaker between similar pages and a real factor in whether visitors stay, not as a lever that lifts a weak page.

Two practical consequences. Do not chase a Lighthouse score of 100; it is a lab score and not what Google uses. And do not ignore a "poor" rating either: a 5-second LCP on mobile costs you visitors whatever it does to rankings.

## How to run a Core Web Vitals test

1. **PageSpeed Insights** ([pagespeed.web.dev](https://pagespeed.web.dev/)): paste a URL to see field data for that page and origin at the top, and a Lighthouse lab run below with specific fixes.
2. **Search Console's Core Web Vitals report:** groups your URLs into good, needs improvement and poor using field data, so you can see which templates have problems across the site.
3. **Chrome DevTools:** the Performance panel shows live LCP, INP and CLS as you use the page, and a recorded trace shows which script caused a slow interaction.
4. **Our [page speed checker](https://abacklaunch.com/tools/page-speed-checker):** measures the causes rather than the vitals. It reports time to first byte (good under about 800 ms, excellent under 200 ms), HTML size and compression, render-blocking scripts and stylesheets in the head, the number of script, style and image requests, whether a sample of your CSS, JavaScript and images is compressed and cached (the [HTTP header checker](https://abacklaunch.com/tools/http-header-checker) shows the exact cache and compression headers), old image formats and missing lazy loading. It runs from Cloudflare's network and links to PageSpeed Insights for the same URL.

Test your home page, your pricing page and one template of each kind (a blog post, a docs page). Pages built from the same template usually share the same problems.

## How to improve LCP

First find the LCP element. PageSpeed Insights names it; on most startup pages it is the hero image, a product screenshot or the main heading. LCP time breaks into four parts, and each has its own fix:

- **Time to first byte:** how long the server takes to answer. Cache HTML at the edge or on a CDN, avoid slow database calls on page load, and avoid [redirect chains](https://abacklaunch.com/glossary/redirect-chain) before the page (the [redirect checker](https://abacklaunch.com/tools/redirect-checker) shows every hop).
- **Resource load delay:** how long before the browser starts downloading the LCP image. Put it in the HTML as a real `<img>`, not a CSS background or something JavaScript inserts later.
- **Resource load time:** how long the image takes to download. Serve it in WebP or AVIF, at the size it is displayed, from your CDN, and give it real alt text while you are there (our [image alt text guide](https://abacklaunch.com/blog/image-alt-text-guide) covers how).
- **Render delay:** time between download and drawing, usually render-blocking CSS, JavaScript or web fonts.

The single most effective change for many sites is telling the browser the hero image matters:

```
<img src="/hero.avif" width="1200" height="675"
alt="Dashboard showing unpaid invoices"
fetchpriority="high">
```

And never lazy-load the LCP image. `loading="lazy"` belongs on images below the fold; on the hero it delays your most important paint. If your site renders everything on the client, the LCP element cannot appear until JavaScript runs, so render the main content on the server where you can.

## How to improve INP

A slow interaction has three parts: input delay (the browser is busy with something else when the user clicks), processing time (your event handlers run) and presentation delay (the browser recalculates layout and paints). Any task over 50 ms that blocks the main thread is a "long task" and a likely cause.

- **Ship less JavaScript.** Remove unused libraries, split code by route and load widgets only when they are needed.
- **Delay third-party scripts.** Chat widgets, analytics and tag managers often cause the long tasks. Load them after the page is interactive, or remove the ones nobody reads.
- **Break up long tasks.** Do the visible update first, then yield to the browser before the rest of the work.
- **Keep the DOM small.** Thousands of nodes make every layout slower. Paginate or virtualize long lists.
- **Give instant feedback.** Show the pressed state or a spinner immediately, then do the heavy work.

A simple way to yield between chunks of work:

```
function yieldToMain() {
if ("scheduler" in window && "yield" in scheduler) return scheduler.yield();
return new Promise((resolve) => setTimeout(resolve, 0));
}

async function saveAll(rows) {
for (const row of rows) {
saveRow(row);
await yieldToMain();
}
}
```

In React, wrapping non-urgent state updates in `startTransition` has a similar effect: the click responds at once and the expensive render follows.

## How to improve CLS

Layout shifts happen when something appears or changes size after the content around it is already drawn. The fixes are mostly about reserving space.

- **Set width and height on every image, video and iframe.** The browser then reserves the right space before the file arrives. For responsive embeds, CSS `aspect-ratio: 16 / 9` does the same.
- **Reserve space for late content.** Cookie banners, promo bars, ads and embeds should have a fixed slot, or overlay the page instead of pushing it down.
- **Do not insert content above what people are reading.** Load "related posts" below, not above.
- **Tame web fonts.** A fallback font with very different metrics makes text reflow when the web font loads. Use `font-display: optional` or a fallback adjusted with `size-adjust`, and preload the main font.
- **Animate with transform.** Moving elements by changing `top` or `height` shifts the layout; `transform` does not.

Shifts that happen within half a second of a user's click or tap do not count, so a menu that opens when clicked is fine.

## A priority list for small teams

| Symptom | Likely cause | First fix | |
| LCP poor on every page | Slow server response | Cache HTML at the edge; check time to first byte | |
| LCP poor only on pages with a hero image | Large, late or lazy-loaded image | WebP or AVIF, correct size, `fetchpriority="high"` | |
| LCP poor on mobile only | Render-blocking CSS and JavaScript on slow networks | Defer scripts, inline critical CSS | |
| INP poor after a redesign | A new framework bundle or third-party widget | Find the long task in DevTools; defer or remove it | |
| CLS poor on blog posts | Images or embeds without dimensions | Width and height on every media element | |
| CLS poor sitewide | A banner or font swap at the top of the page | Reserve the banner's space; fix font loading | |

Work top to bottom, ship one fix at a time, and compare the lab result before and after. Field data takes up to 28 days to reflect a change, so note the date you shipped. Speed is one item on the [on-page SEO checklist](https://abacklaunch.com/blog/on-page-seo-checklist); for the rest of a launch-day audit, the [SEO checker](https://abacklaunch.com/tools/seo-checker) covers titles, headings, links and structured data on the same page, and you can measure yourself against a competitor with [website compare](https://abacklaunch.com/tools/website-compare).

## FAQ

### What are Core Web Vitals?

Core Web Vitals are three metrics Google uses to measure real user experience on a page: Largest Contentful Paint for loading speed, Interaction to Next Paint for responsiveness and Cumulative Layout Shift for visual stability. Google collects them from real Chrome users and uses them as part of its page experience signals.

### What is a good LCP, INP and CLS score?

Good is an LCP of 2.5 seconds or less, an INP of 200 milliseconds or less and a CLS of 0.1 or less, measured at the 75th percentile of visits. Poor starts above 4 seconds for LCP, above 500 milliseconds for INP and above 0.25 for CLS.

### Did INP replace FID?

Yes. Interaction to Next Paint replaced First Input Delay as a Core Web Vital on March 12, 2024. INP measures the full delay of interactions throughout a visit, while FID only measured the input delay of the first one, so INP is the stricter test.

### Do Core Web Vitals affect SEO?

They are a ranking signal, but a modest one. Google uses them as part of page experience and says relevance and content quality come first. Good scores help most when competing pages are similar in quality, and they always help visitors stay on the page.

### How do I run a Core Web Vitals test?

Paste the URL into PageSpeed Insights to see field data from real users and a lab run with fixes, and open Search Console's Core Web Vitals report for a sitewide view. To check server response time, page weight, compression, caching and render-blocking files, use a page speed checker.

### Why do PageSpeed Insights and Search Console show different results?

PageSpeed Insights shows field data for one URL plus a single lab run, while Search Console groups many similar URLs and reports field data over 28 days. Lab runs vary with network and device simulation, so judge progress by the field data trend.

## Check the causes, then the vitals

Core Web Vitals reward the basics done well: a fast server, light pages, images sized and prioritized, little JavaScript in the way, and space reserved for everything that loads late. Start with the free [page speed checker](https://abacklaunch.com/tools/page-speed-checker) to see the server and page-weight problems, fix them, then confirm the result in PageSpeed Insights.

## Related

- [App Store Optimization (ASO): Keywords, Title, Subtitle and Screenshots for iOS and Google Play](https://abacklaunch.com/blog/app-store-optimization-guide)
- [Broken Link Checker Guide: How to Find and Fix Broken Links, 404 Errors and Broken Backlinks](https://abacklaunch.com/blog/broken-link-checker-guide)
- [How to Calculate MRR: The MRR Formula, Worked Examples and Net New MRR](https://abacklaunch.com/blog/how-to-calculate-mrr)
- [All founder guides](https://abacklaunch.com/blog)
