How to Improve Core Web Vitals (Without Chasing a Perfect 100)
Core Web Vitals reward what real users feel, not what a synthetic test scores. Here is how to read the thresholds, tell lab data from field data, and fix the bottlenecks that actually move your numbers, in priority order.
The thresholds you have to hit, and what passing means
There are three Core Web Vitals, each with a single "good" threshold measured at the 75th percentile of real visits: LCP (loading) at or below 2.5 seconds, INP (responsiveness) at or below 200 milliseconds, and CLS (visual stability) at or below 0.1. The middle "needs improvement" bands run 2.5-4.0s for LCP, 200-500ms for INP, and 0.1-0.25 for CLS. Anything worse is "poor." The catch most teams miss: you have to pass all three at once. One metric stuck in the "needs improvement" band is enough to fail the whole assessment in Search Console. These thresholds have been stable: LCP and CLS have not moved, and INP has held its 200ms line since it became a Core Web Vital in March 2024 (replacing First Input Delay). Ignore blog claims that Google quietly dropped the LCP "good" threshold to 2.0s, that is not corroborated by Google's CrUX data or documentation as of mid-2026.
Lab data vs field data: why your green Lighthouse score still fails
This is the single most common source of confusion. Lab data (Lighthouse) loads your page once in a simulated environment, with throttled CPU and a slow default network, and returns one repeatable number. Field data (the Chrome User Experience Report, or CrUX) is a distribution of what real Chrome users actually experienced over a rolling 28-day window, reported at the 75th percentile. Google ranks on the field data. That is why a Lighthouse score of 90+ can sit next to a failing Core Web Vitals report in Search Console. Two consequences follow. First, Lighthouse cannot measure INP at all; it shows Total Blocking Time as a rough proxy, so a page can post 0ms TBT and still fail INP when users interact after load. Second, field data lags up to 28 days, so a real fix will not show up overnight. Use Lighthouse to diagnose, but confirm every change against PageSpeed Insights field data and Search Console.
Step one: fix LCP, the metric that fails most often
Across the web, LCP is the most commonly failed Core Web Vital, and it is also the most fixable because the causes are predictable. On roughly three-quarters of mobile pages the LCP element is an image, yet only about 2% of pages preload that image. Start there. Put a single preload hint in the head with rel="preload" as="image" fetchpriority="high" and add fetchpriority="high" to the actual img tag too. Only preload the one LCP image; preloading everything dilutes the signal. Never set loading="lazy" on the LCP image, since lazy images are skipped by the browser's preload scanner and load late (watch framework defaults like the Next.js Image component, which lazy-loads by default). Then make the image itself cheap: serve WebP or AVIF at the right dimensions with a responsive srcset. Preloading only changes when the download starts; it cannot rescue a slow server, so check Time to First Byte and put a CDN in front of your origin. A well-placed preload plus fetchpriority commonly trims 200-500ms off LCP.
Step two: stop layout shift (CLS), usually the cheapest win
CLS measures unexpected movement of visible content while the page loads, and it is often the fastest metric to clean up because the causes are mechanical. The big four: images and video without explicit width and height (or a CSS aspect-ratio), ad and embed slots that have no reserved space, web fonts that swap and reflow text, and content injected above what the user is already reading (cookie banners, promo bars, late-loading recommendations). Fix it by always setting dimensions or an aspect-ratio box on media, reserving a fixed min-height for every ad, iframe, and dynamic widget so the page does not jump when they arrive, and using font-display: optional or swap with a well-matched fallback to limit font reflow. CLS is the metric where most sites already pass, so if yours is failing, it is usually one or two offenders you can find quickly in PageSpeed Insights or DebugBear by element.
Step three: tame INP, the hard one on mobile
INP measures how fast the page responds to interactions (taps, clicks, key presses), and it is now the most stubborn vital on mobile, where the underpowered hardware exposes JavaScript problems that premium desktops hide. The lab-test median Total Blocking Time can be under 70ms on desktop yet over a second on mid-range phones. INP latency has three parts: input delay (the main thread is busy when the user acts), processing time (your event handlers run), and presentation delay (layout and paint). The fixes target main-thread congestion. Break up long tasks (anything over 50ms blocks the main thread) and yield back to the browser between chunks. Strip unused JavaScript with code splitting and tree shaking, and defer non-critical work (chat widgets, analytics callbacks, social embeds) to idle time with requestIdleCallback or a facade pattern. Keep event handlers lean; do not run analytics or third-party tag callbacks inside the same handler as the interaction's critical work. In React, useTransition and useDeferredValue keep interactions responsive while heavy updates render. Because Lighthouse cannot see INP, you must measure it with field data or the open-source web-vitals library, and capture the element selector and loading state for the worst interaction so you know what to fix.
Prioritize by impact, not by score
Do not optimize all three metrics in parallel. Open PageSpeed Insights and Search Console and find which metric is failing for the most real users at the 75th percentile, then fix that first. The order that works for most sites: confirm the failing metric in field data, reproduce and isolate the cause in Lighthouse or DebugBear, ship the fix, then wait out the 28-day field window before judging it. Two traps to avoid. Do not chase a perfect 100 in Lighthouse; returns above 90 are thin, and tools that promise a guaranteed 100 often delay or skip JavaScript so the test sees a partial page, which can make real-world experience worse. And remember the granularity rule: if a page has too few visits (roughly under 1,000 loads in 28 days), CrUX falls back to origin-level data, so a single slow template can drag down pages that are individually fine.
How Pineido handles this
Most Core Web Vitals failures we see are not mysteries, they are a handful of fixable causes hiding behind a green lab score. Our technical SEO work starts from field data, not Lighthouse vanity numbers, so we are fixing what your actual visitors feel and what Google actually ranks on. The INP Cleanup Sprint is built for the hardest case: long JavaScript tasks, bloated third-party scripts, and unresponsive interactions on mobile. It is a fixed 30-day, fixed-price engagement (our sprints run $8,500), scoped to move your failing metric across the threshold and verified against CrUX, not just a synthetic run. If LCP and CLS are your problem, the same technical SEO work covers preload and priority hints, image format and sizing, reserved layout space, and TTFB. The goal is the same every time: pass all three vitals for real users, then keep them passing.
Ready to ship?
Tell us where you are stuck. We will review it and send a focused recommendation within one business day.
Frequently asked questions
What are the current Core Web Vitals thresholds?
At the 75th percentile of real users: LCP at or below 2.5 seconds, INP at or below 200 milliseconds, and CLS at or below 0.1 are all "good." You must pass all three at the same time to pass the overall assessment, so one metric stuck in the "needs improvement" band fails the whole page.
Why does my Lighthouse score look great but Search Console says I'm failing?
Lighthouse is lab data: one simulated load on your machine. Search Console and PageSpeed Insights field data come from CrUX, real Chrome users over 28 days at the 75th percentile, and that is what Google ranks on. Lighthouse also cannot measure INP at all. Always verify fixes against field data, not the lab score.
Which Core Web Vital should I fix first?
Fix whichever metric is failing for the most real users at the 75th percentile, which you find in PageSpeed Insights or Search Console. LCP fails most often across the web and is usually the most fixable, so it is a common starting point, but let your own field data decide the order.
What is the fastest way to improve LCP?
Preload the single LCP image with fetchpriority high, never lazy-load it, and serve it as WebP or AVIF at the correct size. Then check Time to First Byte and add a CDN. A correct preload plus priority hint commonly cuts 200-500ms off LCP.
How do I improve INP?
INP is mostly about freeing the main thread. Break up tasks longer than 50ms, remove unused JavaScript with code splitting and tree shaking, defer non-critical scripts like chat and analytics to idle time, and keep event handlers lean. Test on real mid-range phones, because desktops hide INP problems.
How long until my Core Web Vitals fixes show up?
Field data updates on a rolling 28-day window, so improvements can take up to a month to appear in Search Console and PageSpeed Insights. Use Lighthouse to confirm the fix immediately in the lab, then wait out the window before judging the real-user result.
Get operations insights weekly
Join service-business operators who get one actionable insight on ops, automation, and growth every week.
No spam. Unsubscribe anytime.
You’re subscribed! Look for our next issue in your inbox.
That did not go through. Please try again, or email [email protected].