Introduction
Core Web Vitals are the three metrics Google uses to measure real-world user experience on your website. They are not a vanity score — they are part of Google's Page Experience ranking signals, which means they can genuinely move you up or down in search results.
The confusing part is that the metric set has changed over the years. First Input Delay (FID) was retired in March 2024 and replaced by Interaction to Next Paint (INP), which is a stricter and more accurate measure of responsiveness. If you last read about Core Web Vitals a few years ago, the thresholds and the third metric have moved on.
This guide covers the current 2026 metric set, the thresholds Google expects you to hit, and the practical fixes that actually move the needle for each one.
The Three Core Web Vitals in 2026
There are three Core Web Vitals. Each measures a different part of how a page feels to a real user.
| Metric | What it measures | Good | Needs improvement | Poor |
|---|---|---|---|---|
| LCP — Largest Contentful Paint | Loading performance | ≤ 2.5s | 2.5s – 4.0s | > 4.0s |
| INP — Interaction to Next Paint | Responsiveness | ≤ 200ms | 200ms – 500ms | > 500ms |
| CLS — Cumulative Layout Shift | Visual stability | ≤ 0.1 | 0.1 – 0.25 | > 0.25 |
Google evaluates these at the 75th percentile of page loads, split across mobile and desktop. That means a "Good" score is not about your fastest visitor — it is about the experience your slowest reasonable visitor gets. If 25% of your users have a poor experience, you fail.
Advertisement
1. Largest Contentful Paint (LCP)
LCP measures how long it takes for the largest visible element on the screen to render. In most cases, that element is an image — a hero banner, a featured photo, or a product shot. Sometimes it is a large text block or a video poster.
Target: Under 2.5 seconds from when the page first starts loading.
Why pages fail LCP
The usual culprits, in rough order of impact:
- •Heavy hero images — a 2MB JPEG hero will not paint in 2.5s on a mobile connection, no matter how good your server is.
- •Render-blocking resources — large CSS and JavaScript files in the
<head>block the browser from painting anything. - •Slow server response — if your Time to First Byte (TTFB) is over 800ms, you have already burned a third of your LCP budget before the browser even starts.
- •Web fonts that swap in late — invisible text waiting on a font download, then a visible jump when it arrives.
The highest-impact LCP fixes
- •Serve images in a next-gen format. Converting hero images from JPEG or PNG to WebP (or AVIF) is the single fastest LCP win for most sites — smaller files download and paint sooner. Run your images through a free converter like WebPConverter.io and swap them in.
- •Preload your hero image. Add
<link rel="preload" as="image" href="...">for the LCP element so the browser starts downloading it immediately, before it even parses the CSS. - •Inline critical CSS. Put the CSS needed for the first paint inline in the
<head>, and defer the rest. - •Preload fonts with
font-display: swap. Show text in a fallback font immediately, then swap in the web font when it arrives. - •Use a CDN and server-side rendering. A CDN gets your HTML to the user faster; SSR means the browser receives ready-to-paint HTML instead of waiting for JavaScript to build the page.
2. Interaction to Next Paint (INP)
INP measures responsiveness — the delay between a user interacting with your page (clicking, tapping, typing) and the browser painting a response. It replaced First Input Delay in March 2024 because FID only measured the first interaction and ignored everything after it.
Target: Under 200 milliseconds.
This is the metric the web struggles with most. Recent data suggests roughly 43% of websites still fail the INP threshold, making it the most commonly failed Core Web Vital.
Why pages fail INP
INP failures are almost always about the main thread being busy when the user tries to interact:
- •Long JavaScript tasks blocking the main thread for 200ms or more.
- •Third-party scripts — analytics, ads, chat widgets — running heavy work on user input.
- •Large client-side rendering work — React/Vue apps that re-render huge trees on every interaction.
- •Expensive event handlers attached to scroll or input events without debouncing.
The highest-impact INP fixes
- •Break up long tasks. Use
setTimeout,scheduler.yield(), orrequestIdleCallbackto split long synchronous work into smaller chunks that let the browser respond to input in between. - •Debounce scroll and resize handlers. These fire constantly; if your handler does real work on every event, it will tank INP.
- •Lazy-load third-party scripts. Load analytics and chat widgets after the page is interactive, or use a partytown-style approach to move them off the main thread.
- •Reduce client-side rendering work. Memoise components, virtualise long lists, and avoid re-rendering large parts of the tree on minor state changes.
- •Use
content-visibility: autofor long, offscreen sections so the browser skips rendering work for them until they are needed.
Advertisement
3. Cumulative Layout Shift (CLS)
CLS measures visual stability — how much the content on your page jumps around as it loads. Every time an image loads without a reserved space and pushes the text down, that is a layout shift. Every time a banner appears and shoves the button you were about to tap out of reach, that is a layout shift.
Target: Under 0.1.
Why pages fail CLS
- •Images and embeds without dimensions — the browser does not know how much space to reserve, so it guesses, then jumps when the asset arrives.
- •Late-loading ads or banners that push content down after first paint.
- •Web fonts causing content to reflow when they swap in.
- •Dynamically injected content above existing content.
The highest-impact CLS fixes
- •Always set width and height on images. This is the single biggest CLS fix. The browser can then reserve the correct space before the image loads. (Using
aspect-ratioin CSS works too.) - •Reserve space for ads and embeds. Use a min-height container for ad slots so late-loading ads do not shove content around.
- •Use
font-display: swapand match your fallback font's metrics to your web font so the swap does not cause a reflow. - •Never insert content above existing content. Add new elements below the fold, or reserve their space in advance.
How to Measure Core Web Vitals
There are two ways to measure these metrics, and you need both:
Field data (real users)
- •PageSpeed Insights — shows real-user data from the Chrome User Experience Report (CrUX) for your URL.
- •Google Search Console — the Core Web Vitals report flags URLs that are failing in the field.
- •The
web-vitalslibrary — install it and collect real-user metrics from your own site:
import { onCLS, onINP, onLCP } from 'web-vitals';
function sendToAnalytics(metric) {
navigator.sendBeacon('/analytics', JSON.stringify(metric));
}
onCLS(sendToAnalytics);
onINP(sendToAnalytics);
onLCP(sendToAnalytics);
Lab data (simulated)
- •Lighthouse — runs a simulated load and scores LCP and CLS (it uses Total Blocking Time as a proxy for INP, since INP needs real interactions to measure).
- •Chrome DevTools Performance panel — for drilling into specific interactions and main-thread work.
Lab data is great for catching regressions before you ship. Field data is the truth Google uses for ranking.
The Fix Order That Actually Works
If you are starting from a failing position, do not try to fix everything at once. Work in this order:
- •Fix CLS first. It is usually the easiest — set image dimensions, reserve ad space, fix fonts. Quick wins that compound.
- •Fix LCP next. Convert and preload your hero image, inline critical CSS, improve your TTFB.
- •Tackle INP last. It is the hardest and most time-consuming, but also where the biggest gains usually hide for JavaScript-heavy sites.
FAQ: Core Web Vitals 2026
Q: What are the Core Web Vitals in 2026? A: LCP (Largest Contentful Paint), INP (Interaction to Next Paint), and CLS (Cumulative Layout Shift). INP replaced First Input Delay in March 2024.
Q: What are the "Good" thresholds? A: LCP ≤ 2.5 seconds, INP ≤ 200 milliseconds, and CLS ≤ 0.1. Google measures these at the 75th percentile across mobile and desktop.
Q: Is INP the same as FID? A: No. FID only measured the delay on the first interaction. INP measures the responsiveness of all interactions across the page load, making it a stricter and more accurate metric.
Q: Do Core Web Vitals affect SEO? A: Yes. They are part of Google's Page Experience ranking signals. They are unlikely to be the single thing that decides your ranking, but in competitive niches they can be a genuine differentiator.
Q: What is the most common failed Core Web Vital? A: INP. Roughly 43% of websites still fail the 200ms threshold, making it the metric the web struggles with most.
Q: How do I measure Core Web Vitals for my site?
A: Use PageSpeed Insights and Google Search Console for real-user field data, Lighthouse for lab data, and the web-vitals JavaScript library to collect real-user metrics from your own site.
The Bottom Line
Core Web Vitals are not going away, and the 2026 metric set — LCP, INP, and CLS — is the one Google is actually using. Fix CLS with image dimensions, fix LCP with next-gen image formats and preloading, and tackle INP by getting heavy work off the main thread.
If you want the quickest LCP win available today, start by converting your hero images to WebP — smaller files paint faster, and faster paint is a better LCP score.
Chris from Pixelbricks
Web designer at Pixelbricks Design in London. Built WEBP Converter to help designers and developers optimise their images for free, right in the browser — no uploads, no limits, no cost.
Visit Pixelbricks Design →Related articles
AVIF vs WebP: Which Next-Gen Image Format Should You Use?
Both AVIF and WebP crush JPEG and PNG. But which one should you actually serve in 2026? A practical comparison of compression, browser support, and when to use each.
A Beginner’s Guide to Responsive Web Design in 2026
Responsive design has moved past media queries alone. Here is how container queries, fluid type with clamp(), and intrinsic grid layouts work together in 2026.
Ready to optimise your images?
Try our free WebP converter and see the difference for yourself. Unlimited conversions, no registration required.
Start converting →