In March 2024, Google replaced First Input Delay (FID) with Interaction to Next Paint (INP) as an official Core Web Vitals metric — and most businesses haven't caught up. As of Q1 2026, only 48% of mobile pages pass all three Core Web Vitals thresholds, according to the Chrome User Experience Report (CrUX). That means more than half of all websites are failing Google's own performance standards for ranking consideration.

If you run a business website and haven't audited your Core Web Vitals since 2023, you're almost certainly leaving ranking positions — and conversions — on the table.

What Are Core Web Vitals?

Core Web Vitals are a set of three specific page experience metrics that Google uses as ranking signals in both desktop and mobile search. They measure real-world user experience — not synthetic lab scores — using data collected from actual Chrome browser sessions (field data).

The three metrics as of 2026:

  • Largest Contentful Paint (LCP): How long it takes for the main content of a page to load and render. Measures perceived load speed from the user's perspective.
  • Interaction to Next Paint (INP): How quickly your page responds to user interactions like clicks, taps, and keyboard inputs. Replaced FID in March 2024.
  • Cumulative Layout Shift (CLS): How much the visual layout of a page shifts unexpectedly while loading. Measures visual stability.

The 2026 Thresholds: What "Good" Actually Means

Metric Good Needs Improvement Poor
LCP ≤ 2.5s 2.5s – 4.0s > 4.0s
INP ≤ 200ms 200ms – 500ms > 500ms
CLS ≤ 0.1 0.1 – 0.25 > 0.25

Google uses the 75th percentile of all field data sessions to classify a URL — meaning your worst-performing 25% of user sessions determine your score. This is why lab tests (like running Lighthouse locally on a fast computer) often look great while real-world field data still shows "Needs Improvement."

Do Core Web Vitals Actually Affect Rankings?

Yes — but the effect is often misunderstood. Core Web Vitals are a tiebreaker signal: when content relevance and authority are roughly equal between two pages, the one with better CWV scores wins. For highly competitive queries where many sites have strong content and backlink profiles, this tiebreaker is frequently decisive.

Google's own documentation states: "A good page experience doesn't override having great, relevant content." But in practice, most competitive local and SMB markets have multiple sites with comparable content quality — which means CWV increasingly determines the ranking order.

The more significant and often overlooked impact: Core Web Vitals directly affect conversion rate, independent of SEO. The data here is unambiguous:

  • Vodafone improved LCP by 31% and saw an 8% increase in sales conversions (Google Case Studies, 2024)
  • eBay improved page load performance by 100ms and saw a 0.5% increase in "Add to Cart" events — at eBay's scale, that's hundreds of millions in revenue (eBay Tech Blog)
  • Swappie improved CWV across their mobile site and saw a 42% increase in revenue per session (Google, 2024)
  • The Economic Times of India reduced LCP from 4.5s to 1.5s and saw a 43% increase in page views and 25% improvement in user session duration

For small and medium businesses, the conversion impact is proportionally the same — even if the absolute revenue numbers are smaller.

LCP: Largest Contentful Paint

What Causes Poor LCP

The LCP element is almost always one of: the hero image, a large above-the-fold text block, or a video poster frame. The most common causes of slow LCP are:

  • Unoptimized hero images: A 3MB JPEG hero image served to mobile users is the single most common LCP killer. Modern sites should serve WebP or AVIF format at appropriate sizes via srcset, with the hero image preloaded in the <head>.
  • Render-blocking resources: CSS and JavaScript files that block the browser from painting any content until they've fully loaded. Unused CSS is a major contributor — most WordPress sites load 200-400KB of CSS that's irrelevant to the current page.
  • Slow server response time (TTFB): If your server takes 1.5+ seconds to return the initial HTML, your LCP cannot be good regardless of what else you optimize. TTFB over 800ms is a red flag. Use a CDN and/or edge hosting to address this.
  • No <link rel="preload"> for LCP image: Browsers discover hero images late in the loading process because they're referenced in CSS, not HTML. Adding a preload hint in <head> tells the browser to start fetching it immediately.

LCP Fixes by Impact

  1. Convert hero image to WebP/AVIF and add preload hint (high impact, low effort)
  2. Move to CDN hosting if on shared hosting (high impact, medium effort)
  3. Remove unused CSS — use PurgeCSS or the Coverage tab in DevTools (high impact, medium effort)
  4. Implement server-side caching or static site generation (high impact, high effort)
  5. Defer non-critical JavaScript (medium impact, low effort)

INP: Interaction to Next Paint

INP is the newest Core Web Vital and the one most businesses are currently failing. It measures the delay between a user interaction (click, tap, keyboard input) and the next visual update the browser renders in response. A poor INP score means your site feels sluggish and unresponsive — users click buttons and nothing seems to happen.

Why INP Is Hard to Fix

Unlike LCP (which is primarily a network/asset loading problem), INP is a JavaScript execution problem. If your main thread is busy processing JavaScript when a user clicks something, the browser can't respond until that work finishes. The most common INP culprits:

  • Long JavaScript tasks: Any JS task that runs for more than 50ms blocks the main thread and delays interaction response. Third-party scripts (chat widgets, analytics, tag managers) are major contributors — many fire large JS payloads on page interaction.
  • Excessive DOM size: Pages with 1,500+ DOM elements take significantly longer to re-render after interactions. This is common on WordPress sites with complex page builders.
  • Hydration cost in JavaScript frameworks: React, Vue, and Angular apps that do heavy client-side hydration can have poor INP even when initial load feels fast. Next.js's partial hydration (React Server Components) and streaming SSR significantly reduce this.
  • Unoptimized event handlers: onClick handlers that do too much work synchronously before returning control to the browser. Defer non-visual work with setTimeout(fn, 0) or requestIdleCallback.

INP Benchmark: Where Most Sites Stand

According to CrUX data analyzed by Rick Viscomi (Chrome performance team) in Q4 2025, the median INP for mobile pages is approximately 320ms — above the "Needs Improvement" threshold. Only 55% of mobile pages achieve a "Good" INP rating. Sites built on heavy page builders (Elementor, Divi, WPBakery) frequently score in the 400-700ms range due to the JavaScript overhead of drag-and-drop architecture.

CLS: Cumulative Layout Shift

CLS measures how much visible content unexpectedly moves around while a page loads. A high CLS score means users click on something and end up clicking something else because the layout shifted. This is particularly damaging for conversion — if a "Book Now" button moves after a user taps it, they often abandon rather than try again.

Common CLS Causes

  • Images without explicit dimensions: When width and height attributes are missing from <img> tags, the browser doesn't know how much space to reserve. The image loads and pushes content down.
  • Web font swaps: Fonts that load after the browser has already rendered text in a fallback font cause layout shifts. Using font-display: optional or font-display: swap with size-adjusted fallbacks eliminates most font CLS.
  • Ad slots and embeds without reserved space: Dynamically injected ad units are the #1 CLS offender on ad-supported sites. Reserve explicit height for every ad slot with min-height CSS.
  • Animations that affect layout: CSS transitions on properties like height, top, or margin cause layout recalculations. Animate transform and opacity instead — these run on the compositor thread and don't cause CLS.

How to Measure Your Core Web Vitals

There are two types of CWV data — lab data and field data. Only field data affects rankings.

  • Google Search Console (free): The Core Web Vitals report shows your field data segmented by URL, device type, and metric. This is the most important tool for understanding your ranking exposure.
  • PageSpeed Insights (free): Combines lab data (Lighthouse) and field data (CrUX) for any URL. Shows both scores and the specific opportunities to address.
  • Chrome DevTools Performance tab: For diagnosing specific INP issues — use the Interactions track to identify which event handlers are causing long tasks.
  • web-vitals JavaScript library: Add Google's open-source web-vitals.js to your site to measure real-user CWV in your own analytics dashboard. Sends LCP, INP, and CLS for every session.

The Business Case: Core Web Vitals ROI

Here's the framing that matters for business owners: every 100ms of page load improvement correlates with approximately 1% improvement in conversion rate (Deloitte, 2020 — and replicated multiple times since). For a site generating $50,000/month in leads, improving page load from 5 seconds to 2 seconds represents a potential 2-3% conversion rate lift — $1,000-$1,500/month in additional revenue, every month.

At Nerd Stack, we typically reduce client page load times from 4-8 seconds (common on WordPress/Wix/Squarespace templates) to under 1.5 seconds on Next.js. The Cascade Public Safety rebuild reduced load time from 8.2 seconds to 1.1 seconds — a 87% improvement. That's not an outlier; it's what happens when performance is treated as a first-class requirement, not an afterthought.

2026 Action Plan: Fix Priority Order

  1. Check Search Console CWV report first — understand your actual field data before touching anything
  2. Fix images: Convert to WebP, add srcset for responsive sizes, add explicit width/height attributes, add preload for LCP image
  3. Audit third-party scripts: Remove any tag or widget you can't justify. Each one adds 50-300ms of potential INP delay.
  4. Reserve space for dynamic content: min-height on ad slots, aspect-ratio on image containers, explicit dimensions on embeds
  5. Move to edge hosting: If TTFB is over 800ms, no amount of other optimization will fully save your LCP
  6. Consider framework migration for sites built on heavy page builders — this is the only reliable path to excellent INP scores on complex, interactive sites

Sources: Chrome User Experience Report (CrUX); Google web.dev Case Studies — Vodafone, Swappie, Economic Times of India; eBay Tech Blog — Shopping for Speed; Google Search Central — Core Web Vitals Documentation; Deloitte — Milliseconds Make Millions (2020).