Core Web Vitals in 2026 means passing three Google-defined metrics: LCP, INP, and CLS. Your site must pass them at the 75th percentile of real-user Chrome data. Below you will find the current thresholds, why INP replaced FID, framework-specific fixes for Next.js and Astro, and how to monitor field performance rather than rely on lab scores alone.

Key takeaways

  • INP replaced FID as a Core Web Vital in March 2024. The 2026 "Good" thresholds remain LCP ≤ 2.5 s, INP ≤ 200 ms, and CLS ≤ 0.1, all measured at the 75th percentile.
  • A large share of mobile origins still fail LCP and INP, according to HTTP Archive's field data. Most sites ship an experience Google is actively penalizing in search.
  • Framework choice changes your starting point. Astro ships no JavaScript by default. Next.js's App Router needs deliberate "use client" boundaries to avoid INP regressions.
  • CrUX field data, not Lighthouse lab scores, is what Google uses for ranking signals. Monitoring should prioritize real user data over synthetic tests.
  • Architecture changes compound: our SleepDr migration from WordPress to Next.js raised its Lighthouse score from 35 to 94. This shows how much the underlying stack affects these metrics.

Updated 30 October 2026: sources added, experience claims checked against our project record, summary added.


Brass stopwatch with blank dial beside steel calipers on a dark surface

What exactly are Core Web Vitals in 2026 -- and why did the goalposts move?

Core Web Vitals are Google's three standard user-experience metrics: LCP, INP, and CLS. They factor into search rankings and, more directly, whether visitors stay on a page or leave. They measure what users feel: how fast content appears, how quickly the page responds to a tap, and whether the layout holds still or jolts beneath their thumb.

FID was easy to pass. Almost every site cleared it, because it measured only the delay of a single first click. INP officially replaced FID in March 2024. HTTP Archive's field data shows a much smaller share of origins meeting the INP "Good" threshold than ever passed FID. Google moved the goalposts for a reason: INP measures every interaction across an entire session, not just the first one.

Here is where the three metrics stand in 2026:

  1. Largest Contentful Paint (LCP) -- loading performance, measured as the render time of the largest visible element.
  2. Interaction to Next Paint (INP) -- responsiveness, measured as the worst-case interaction latency during the full page session.
  3. Cumulative Layout Shift (CLS) -- visual stability, measured as the sum of unexpected layout-shift scores.

Google has also signalled interest in a Smoothness metric that would target animation frame drops and scroll jank. It is not yet an official Core Web Vital, but you can already observe it through the Long Animation Frames (LoAF) API. Teams that track LoAF entries now will have a baseline if Google eventually folds it into CrUX.


What are the exact thresholds you need to hit in 2026?

Your pages must score "Good" at the 75th percentile of real Chrome User Experience Report (CrUX) field data, not in a Lighthouse lab run on a fast laptop over fibre. The current thresholds:

Metric Good Needs Improvement Poor What It Measures
LCP ≤ 2.5 s 2.5 s - 4.0 s > 4.0 s Render time of the largest visible element
INP ≤ 200 ms 200 ms - 500 ms > 500 ms Worst-case interaction latency across the session
CLS ≤ 0.1 0.1 - 0.25 > 0.25 Sum of unexpected layout-shift scores

"75th percentile" means 75% of your actual visitors need to land in the "Good" column, including people on older Android phones on patchy mobile connections. In production, the gap between lab scores and field scores is usually biggest for INP, and smaller but still real for LCP. Staging shows you only part of the picture.


Why does LCP still fail on 37% of mobile origins -- and how do you fix it?

LCP fails on most sites because teams optimise the wrong part of it. HTTP Archive's field data shows roughly 63% of mobile origins passing LCP, which makes it the second-hardest Core Web Vital to clear after INP. So the fix starts with finding which of the four LCP sub-parts is eating your time budget.

Google's documentation breaks LCP into four sub-parts. The breakdown shows where your LCP time actually goes:

Sub-Part Budget Target What It Covers
Time to First Byte (TTFB) < 800 ms Server response, DNS, TLS, redirects
Resource Load Delay < 10% of LCP Gap between TTFB and when the LCP resource starts loading
Resource Load Duration < 40% of LCP Time to download the LCP image or video
Element Render Delay < 10% of LCP Gap between resource loaded and pixel painted

How do you cut TTFB below 800 ms?

Move rendering to the edge. If you still serve from a single-region origin, you are handing 200-800 ms to every user outside that region before anything else happens. Next.js and Astro sites deployed to an edge network such as Vercel's commonly see TTFB well under 200 ms worldwide. Our Next.js development practice and Astro development practice default to edge-first deployment for this reason.

How do you eliminate Resource Load Delay?

Your LCP image must appear in the initial HTML response, not be injected later by JavaScript. A two-line fix solves most cases where the hero image loads too late:

<!-- In <head>: preload the LCP image so the browser fetches it immediately -->
<link rel="preload" as="image" href="/hero-visual.webp" fetchpriority="high" />
// In your component: set fetchPriority so the browser does not deprioritize it
<img src="/hero-visual.webp" fetchpriority="high" alt="Product dashboard" />

Preloading the LCP resource usually closes most of the gap between a slow Resource Load Delay and the target of under 10% of your LCP budget. The browser starts fetching the image as soon as it reads the HTML, instead of waiting for JavaScript to inject it.

Avoid lazy-loading your LCP element. It is one of the most common mistakes in Next.js App Router projects. The <Image> component defaults to loading="lazy". If your hero image is the LCP element, that setting tells the browser to deprioritise the most important resource on the page.


Row of blank black keycaps with one pressed down, glowing orange from beneath

Where does INP break in Next.js 15 App Router -- and what replaced FID?

INP (Interaction to Next Paint) measures how slow every interaction in a session is, then reports the worst one. It replaced FID because FID measured only the delay of the first input, ignoring a sluggish filter dropdown a user taps three scrolls later. INP catches that.

INP consistently breaks in three places in Next.js 15 App Router projects:

  1. Unoptimized client-side state hydration. When you mark a large component tree with "use client", React hydrates the entire subtree on load. Every event handler in that subtree competes for the main thread. Catalog pages where a single "use client" boundary wraps many interactive product cards often see INP spike well past the 200 ms threshold.
  2. Synchronous useEffect chains in route transitions. App Router's streaming model can hide slow server responses, but useEffect hooks still fire synchronously on the client. Fetching extra data inside useEffect and updating state blocks the main thread at the exact moment a user tries to interact.
  3. Third-party script execution during interaction frames. Analytics snippets, chat widgets, and consent managers often run long tasks (over 50 ms) that collide with user input. Even "async" scripts run on the main thread once downloaded.

How do you fix INP in practice?

Break up long tasks with scheduler.yield(). Chrome 129+ supports the Scheduler API natively. For older browsers, you can use a zero-delay setTimeout as a fallback. It is not ideal, but it beats a 400 ms blocked frame:

async function handleFilterClick(filters) {
  // Process first batch
  const results = applyFilters(filters);

  // Yield to the browser so it can paint the next frame
  if ('scheduler' in window && 'yield' in scheduler) {
    await scheduler.yield();
  } else {
    await new Promise(resolve => setTimeout(resolve, 0));
  }

  // Then update the heavy UI
  renderFilteredResults(results);
}

Shrink your "use client" boundaries. Instead of wrapping an entire page section, isolate interactivity in the smallest possible leaf components. Splitting one large client component into several leaf components, each with its own "use client" directive and no shared state above them, commonly brings catalog page INP back under the 200 ms threshold in production Next.js sites.

Defer third-party scripts with the afterInteractive strategy in Next.js, or load them inside a requestIdleCallback wrapper in Astro. If you run Google Tag Manager, move non-critical tags to a "delayed" trigger that fires a few seconds after page load or on first user scroll.


Why do your third-party scripts still tank CLS even when they load async?

Async loading stops scripts from blocking the HTML parser, but it does not stop them from injecting elements that shift your layout after the page has painted. CLS measures every unexpected layout shift across the page's lifespan, and most third-party widgets (cookie banners, chat bubbles, newsletter popups, embedded social feeds) inject DOM nodes without reserving space first.

Here is how to fix the three worst CLS offenders:

  • Cookie consent banners: Reserve a fixed-height container (typically 72-96 px) at the bottom of the viewport using CSS. Even if the banner script loads late, the space is already claimed, so your CLS contribution from consent banners should be close to 0.
  • Chat widgets: Most chat SDKs inject a floating button that triggers a reflow in surrounding content on mobile. Set a min-height on your page footer, or use position: fixed with explicit bottom and right values so the widget never joins the document flow.
  • Web fonts: Use font-display: optional for body text and font-display: swap only for display headings. Preload your primary font file. Adding a single <link rel="preload" as="font"> tag and switching the body font to font-display: optional often drops font-related CLS close to zero.

Always set explicit width and height attributes (or CSS aspect-ratio) on every <img>, <video>, and <iframe>. It is the simplest, highest-impact CLS fix. HTTP Archive's markup data shows a large share of mobile pages still ship images without explicit dimensions.


Which framework gives you the best Core Web Vitals scores out of the box?

Astro delivers strong Core Web Vitals scores by default for content-heavy sites, because it ships zero JavaScript to the client unless you opt in with client: directives. For app-like interactivity, Next.js App Router with React Server Components strikes a strong balance of server rendering, streaming, and selective hydration. Here is how the frameworks typically compare in production:

Framework Typical LCP (p75, mobile) Typical INP (p75, mobile) Typical CLS (p75) Best For
Astro 5.x 1.2 - 1.8 s 80 - 140 ms 0.01 - 0.04 Content sites, blogs, marketing pages
Next.js 15 App Router 1.6 - 2.4 s 120 - 220 ms 0.02 - 0.08 SaaS dashboards, ecommerce, dynamic apps
Payload CMS + Next.js 1.8 - 2.6 s 140 - 240 ms 0.03 - 0.10 CMS-driven sites needing editorial flexibility

These ranges reflect the spread you see in public CrUX field data sorted by technology. Your own results will vary with content weight, third-party scripts, and hosting setup.

If you are considering a migration from WordPress or another legacy CMS, the performance gain from moving to Astro or Next.js on Vercel can be large. Our SleepDr migration took its Lighthouse score from 35 to 94 before any manual fine-tuning, purely from the architecture change.


How should you measure Core Web Vitals in production -- lab vs. field?

You should measure Core Web Vitals using field data from CrUX or a Real User Monitoring (RUM) tool, not lab-only tools like Lighthouse. Lab tools are useful for debugging, but Google uses CrUX field data for ranking signals, and lab scores can be very different from field scores, especially for INP.

Here is a monitoring stack worth setting up:

  1. CrUX Dashboard (free) -- connects to BigQuery and shows your rolling 28-day p75 metrics. This is the ground truth Google uses for Search Console reporting.
  2. web-vitals.js library (free, small footprint) -- embed it in your site to capture LCP, INP, CLS, TTFB, and FCP from every real session, then send the data to your analytics platform.
  3. Vercel Speed Insights (included with Pro plans) -- if you deploy on Vercel, this gives you per-route CrUX-aligned data without extra setup.
  4. SpeedCurve or Calibre (paid) -- for teams that need synthetic monitoring, RUM, and competitive benchmarking in one place.
// Minimal web-vitals.js setup for Next.js App Router
// app/layout.tsx
import { onLCP, onINP, onCLS } from 'web-vitals';

function sendToAnalytics(metric) {
  const body = JSON.stringify({
    name: metric.name,
    value: metric.value,
    rating: metric.rating,
    delta: metric.delta,
    id: metric.id,
    navigationType: metric.navigationType,
  });
  // Use sendBeacon so the data survives page unload
  navigator.sendBeacon('/api/vitals', body);
}

onLCP(sendToAnalytics);
onINP(sendToAnalytics);
onCLS(sendToAnalytics);

Set up alerts at the p75 level for each metric. When your INP p75 crosses 180 ms, leaving 20 ms of headroom below the 200 ms threshold, you want to know before it gets worse. This kind of alerting fits naturally into a Supabase-backed analytics pipeline, the same pattern behind Not Another Sunday's programmatic SEO infrastructure.


What advanced techniques improve animation smoothness?

Animation smoothness (frame drops, scroll jank and CSS transition stutter) is not a Core Web Vital, but you can already track it with the Long Animation Frames (LoAF) API in Chrome 123+. Capture LoAF data now and you have a baseline if Google ever adds a smoothness metric.

Three techniques that prepare you today:

  1. Audit your CSS animations with will-change and contain. Adding will-change: transform to animated elements moves them to their own compositor layer, keeping animation off the main thread. Overuse triggers excessive memory use, so apply it only to elements that are actively animating, and remove it once the animation ends.

  2. Replace JavaScript scroll handlers with scroll-timeline CSS. Chrome 115+ supports CSS animation-timeline: scroll(), letting you drive scroll-linked animations entirely on the compositor thread. No requestAnimationFrame loops, no main-thread blocking, no dropped frames.

  3. Use content-visibility: auto on below-the-fold sections. This CSS property tells the browser to skip rendering work for off-screen content until the user scrolls near it. On long resource-hub pages, content-visibility: auto commonly cuts initial render time a lot and removes scroll jank from Chrome's Performance panel.

View Transitions API for route changes. If you run Next.js App Router, the View Transitions API gives you native-like page transitions without the layout shifts that JavaScript-driven animations cause. Every route change becomes a smooth cross-fade instead of a jarring white flash, and your CLS stays at 0 during navigation.


What is the real business impact of passing all three Core Web Vitals?

Passing all three Core Web Vitals is linked to lower abandonment and measurable conversion lifts in ecommerce and SaaS verticals. Google's own research found visitors are much less likely to abandon a page load on sites that meet the thresholds.

Google's published case studies back this up. Vodafone saw a sales increase after improving LCP, and Tokopedia saw a longer average session duration after improving its CLS scores.

If your site currently fails one or more Core Web Vitals, fixing them will improve your numbers. The open question is how much traffic and revenue you lose every week you delay. You can request a free performance audit from Social Animal to find out.


How do you build a Core Web Vitals optimization workflow your team will actually follow?

Tie performance budgets to your CI/CD pipeline and the workflow lasts. It catches regressions before they reach production, instead of letting them show up in your CrUX scores 28 days later. Here is a 5-step process that keeps performance regressions out of production:

  1. Set per-route performance budgets. Define LCP ≤ 2.2 s, INP ≤ 170 ms, CLS ≤ 0.05 for your highest-traffic templates. These are tighter than Google's thresholds, which gives you headroom.
  2. Add Lighthouse CI to your GitHub Actions or Vercel build step. Fail the build if any budget is exceeded. This catches hero image regressions, new third-party scripts, and unoptimized font loads before merge.
  3. Run weekly CrUX pulls into a shared dashboard, for example Looker Studio connected to BigQuery. Track your p75 metrics over 4, 8, and 12-week windows.
  4. Assign one engineer as the "performance champion." This person triages regressions, reviews PRs for performance impact, and owns the quarterly audit cycle.
  5. Run quarterly deep audits with framework-specific tooling: the Next.js Bundle Analyzer, Astro's built-in astro check, and Chrome DevTools Performance panel with CPU throttling set to 4x.

Teams that keep good Core Web Vitals scores treat performance as an ongoing practice, not a one-time project. If you want help setting up this workflow, our blog covers the details of each step, and our team can embed directly with yours for the first sprint.


FAQ

What is the difference between INP and FID?

INP measures how slow every interaction in a session is and reports the worst one, while FID measured only the delay of the very first interaction. Google retired FID in March 2024 and replaced it with INP to reflect responsiveness across the whole session, not just one click.

FID's blind spot meant a page could score perfectly while delivering 500 ms of lag on a dropdown tap 30 seconds into the session. INP closes that gap by tracking a high-percentile interaction delay across the whole visit. If your site passed FID easily, do not assume it passes INP. HTTP Archive's field data shows a meaningful share of origins that cleared FID still fail INP.

How often does Google update Core Web Vitals thresholds?

Google updates Core Web Vitals roughly once a year, with public announcements usually arriving 6 to 12 months before enforcement begins, which gives teams time to prepare. Check the Chrome Developers blog and Web Vitals changelog every quarter to stay ahead of changes.

The FID-to-INP switch was announced in May 2022, became experimental in 2023, and became the official metric in March 2024. CLS scoring was refined in 2021, when Google switched from cumulative to session-window scoring. Google has published research on an animation-smoothness metric but has not announced one; the LoAF API is the closest thing you can measure today.

Can you pass Core Web Vitals on a WordPress site?

Yes, but it takes more work than on framework-native stacks like Next.js or Astro. Passing scores need aggressive caching, critical CSS inlining, image lazy-loading with explicit dimensions, and the removal of a large share of the plugins many WordPress sites pile up over time.

The main problems on WordPress are render-blocking plugin scripts, slow PHP-driven TTFB without page caching, and CLS from ad injection and dynamic widget loading. Tools like WP Super Cache or Cloudflare APO help with caching. If your WordPress site gets significant monthly traffic and still struggles with Core Web Vitals, a migration to Next.js or Astro often pays off better than more WordPress optimisation, as it did for the bdManagedIT migration from WordPress to Astro.

Does passing Core Web Vitals guarantee higher Google rankings?

No. Core Web Vitals are a confirmed ranking signal, but one of hundreds. Google's own documentation calls page experience a tiebreaker signal: when two pages have similar relevance and authority, the one with better Core Web Vitals tends to rank higher.

In competitive verticals, passing Core Web Vitals will not overcome a large authority gap on its own. But sites that move from "Poor" or "Needs Improvement" to passing all three metrics do tend to see organic traffic gains within a few months, because the side effects (lower bounce rates, longer sessions, higher engagement) feed back into ranking signals too.

How long does it take to see ranking improvements after fixing Core Web Vitals?

Expect roughly 6-12 weeks from deploy to a measurable ranking shift. CrUX data uses a rolling 28-day collection window, so your changes need that long just to show up in the dataset. Ranking changes typically follow within another crawl cycle or two.

Check whether your CrUX data has updated in the Core Web Vitals report in Google Search Console. If your field data still shows old numbers, your changes either have not been live long enough or are not reaching enough real users to shift the 75th percentile.

What tools give the most accurate Core Web Vitals measurements?

The most accurate source is CrUX, the Chrome User Experience Report, because it is the exact dataset Google uses for ranking signals, not an estimate. You can access CrUX data through PageSight Insights, Search Console, or BigQuery, depending on how much detail you need.

For real-time monitoring, the web-vitals.js library, maintained by Google, captures LCP, INP, and CLS from every session and lets you send the data to any analytics backend. Lighthouse and WebPageTest are lab tools: great for debugging specific issues, but they do not represent your real user mix. Run lab audits for diagnostics and RUM-based monitoring for tracking progress over time.

Should you optimize for Lighthouse score or CrUX field data?

Optimise for CrUX field data instead of chasing a perfect lab score. Your Lighthouse score is a lab-based estimate run on a simulated mid-range device with throttled connectivity. It is useful for spotting issues but is not what Google uses for ranking.

Sites with high Lighthouse scores can still fail CrUX INP if their real users are on slower devices running more browser extensions. Conversely, sites with middling Lighthouse scores can pass every CrUX threshold if their audience uses mostly modern devices on fast connections. Use Lighthouse to find problems. Use CrUX to check whether you fixed them for your real visitors.

How much does professional Core Web Vitals optimization cost?

A focused Core Web Vitals engagement at Social Animal is typically scoped at 2-4 weeks, covering audit, implementation, and checking results against CrUX field data. For a Next.js or Astro site with 5-15 unique templates, that usually means somewhere between 40 and 80 hours of senior engineering time.

Pricing depends on your framework, number of page templates, third-party script complexity, and whether you need ongoing monitoring setup. The ROI maths is simple: if your site makes $100,000 a month in revenue and a Core Web Vitals fix delivers even a 5% conversion lift, the engagement pays for itself within weeks. You can request a free audit to get a scoped estimate before committing.