Core Web Vitals have been a Google ranking factor since May 2021. In March 2024, Google made the most significant update to the metrics since their launch: replacing First Input Delay (FID) with Interaction to Next Paint (INP).
If you haven't audited your Core Web Vitals performance since early 2024, you may be failing the updated standard without knowing it — because the new INP metric is significantly harder to pass than FID was.
What it measures: How long it takes for the largest visible content element on the page to fully render — typically a hero image, a large text block, or a video thumbnail.
Why it matters: LCP represents the point at which users perceive the page as "loaded." Slow LCP = users see a blank or partially loaded page for too long = poor experience.
Target scores:
| Status | Threshold |
|---|---|
| 🟢 Good | 2.5 seconds or faster |
| 🟡 Needs Improvement | 2.5–4.0 seconds |
| 🔴 Poor | Over 4.0 seconds |
What it measures: The delay between a user interacting with the page (clicking a button, tapping a link, pressing a key) and the browser painting the next visual response. INP measures the worst interaction across an entire page visit.
Why it matters: INP replaces FID (First Input Delay), which only measured the very first interaction. INP measures all interactions throughout a visit — capturing the sluggishness of complex pages with many JavaScript-heavy interactions.
Target scores:
| Status | Threshold |
|---|---|
| 🟢 Good | 200 milliseconds or faster |
| 🟡 Needs Improvement | 200–500 ms |
| 🔴 Poor | Over 500 ms |
What it measures: The visual stability of the page — how much content unexpectedly shifts position while the page loads. A page that "jumps" as images load or ads appear has high CLS.
Why it matters: Layout shifts cause users to click the wrong button, lose their reading position, or accidentally tap unintended links. High CLS correlates strongly with user frustration.
Target scores:
| Status | Threshold |
|---|---|
| 🟢 Good | 0.1 or lower |
| 🟡 Needs Improvement | 0.1–0.25 |
| 🔴 Poor | Over 0.25 |
Common CLS causes: Images without defined dimensions, dynamically injected ads, fonts loading late (FOUT/FOIT), third-party embeds without reserved space.
Google uses Core Web Vitals as a tie-breaker ranking signal within the broader "page experience" signal. The official position: two pages with equal content quality and authority will have the better-performing page ranked higher.
In practice, the impact is subtle for most queries but meaningful in competitive niches. Passing all three Core Web Vitals earns a "page experience" signal that failing sites don't receive.
More significantly for 2026: Google AI Overviews and featured snippet selection also considers page experience. A slow, poor-experience page is less likely to be cited or featured — even with excellent content.
Search Console's Core Web Vitals report shows your real-user data (CrUX — Chrome User Experience Report data collected from real Chrome users visiting your site).
Access: Search Console → Core Web Vitals → Mobile/Desktop
Pages categorised as "Poor" are the priority to fix. "Needs Improvement" is the next priority. "Good" means you're passing.
Visit pagespeed.web.dev → Enter any URL → Run the test.
PageSpeed Insights shows both:
The field data is what matters for rankings. Lab data is useful for diagnosing the cause of poor field data.
For deep diagnosis — identifying exactly which JavaScript functions are causing INP issues, which elements are causing layout shifts — Chrome DevTools provides performance traces that point to the exact code causing problems.
Poor LCP is almost always caused by one or more of these factors:
The LCP element is usually your hero image. If it's large and unoptimised:
fetchpriority="high": Tell the browser this image is the most important element to load<img src="hero.webp" fetchpriority="high" alt="Hero image">
Preload the LCP image in <head>:
<link rel="preload" as="image" href="/images/hero.webp">
CSS and JavaScript that block the browser from rendering HTML delay LCP. Diagnose with PageSpeed Insights' "Render-blocking resources" opportunity.
<script defer src="..."> or <script async src="...">LCP is heavily influenced by Time to First Byte (TTFB) — how long the server takes to respond. Cheap shared hosting with poor TTFB directly causes LCP failures.
INP is the hardest metric to fix because it requires addressing JavaScript execution delays.
In Chrome DevTools:
The most common INP failure cause: too much JavaScript running on user interactions.
Third-party scripts (Google Analytics, Facebook Pixel, HubSpot chat, Intercom) execute in the main thread and contribute to INP.
async or deferEvery <img> tag should have explicit width and height attributes:
<img src="product.webp" width="600" height="400" alt="Product">
This tells the browser how much space to reserve before the image loads, preventing layout shift.
Dynamically loaded ads and embeds that don't have pre-reserved space cause CLS.
.video-container {
aspect-ratio: 16 / 9;
width: 100%;
}
Web fonts that load after the page causes "Flash of Unstyled Text" (FOUT), which shifts layout.
font-display: swap in @font-face declarations<link rel="preload" as="font" href="/fonts/main.woff2" crossorigin>
| Platform | LCP Impact | INP Impact | CLS Impact | Notes |
|---|---|---|---|---|
| WordPress + WP Rocket | Strong (caching, image lazy load) | Moderate (JS optimisation) | Strong (deferred JS) | Best all-in-one option |
| WordPress + Elementor | Moderate | High risk (heavy JS) | Moderate | Consider Gutenberg for simpler pages |
| WordPress + LiteSpeed Cache | Strong | Strong | Strong | Best on LiteSpeed servers |
Core Web Vitals are not going away — they're becoming more sophisticated. The shift from FID to INP is the clearest signal of this: Google is raising the bar for what constitutes a "good" user experience.
Passing Core Web Vitals is both a ranking prerequisite and a business improvement. Faster, more stable, more responsive pages convert better, rank better, and earn more AI feature citations.
Audit with Search Console first. Fix failing LCP with image optimisation and hosting. Address INP with JavaScript cleanup. Solve CLS with explicit image dimensions.
Contact us for a Core Web Vitals audit