How to Pass the Core Web Vitals Assessment: Step by Step (2026)
Find the metric that fails on mobile, fix TTFB and LCP before INP and CLS, and see in your field data when PageSpeed Insights turns from Failed to Passed.
Passing the Core Web Vitals in short
You pass the Core Web Vitals when real Chrome visitors get a good LCP (2.5 seconds or less), INP (200 milliseconds or less) and CLS (0.1 or less) at the 75th percentile of the last 28 days. Fix only what fails, phones before desktop: when LCP fails, start with the time to first byte, then LCP itself, then INP and CLS.
What does "Core Web Vitals Assessment: Failed" mean?
"Core Web Vitals Assessment: Failed" is the verdict PageSpeed Insights gives on field data: at least one of LCP, INP and CLS is not good at the 75th percentile of the last 28 days of Chrome visits. The verdict is for the URL you tested, or for the whole site under Origin when that URL has too few visits. The assessment reads "Passed" when all three are good, or when LCP and CLS are good and INP has too little data (PageSpeed Insights documentation).

The Lighthouse score under it is one simulated load and can be 100 while the assessment fails (why the two disagree). Read the mobile tab first: phones often fail where desktop passes.
Google ranks on the field data, each metric on its own: a metric helps a little as it moves toward good, up to good and no further (Core Web Vitals and SEO).
Step 1: How do you test which metric fails, and on which pages?
Google Search Console's Core Web Vitals report, under Experience, names the failing metric and the group of pages, for mobile and desktop separately; PageSpeed Insights tests one URL at a time. An issue reads like "LCP issue: longer than 2.5s (mobile)", and a group gets the rating of its worst metric.

A group is usually one template, so test one URL of each failing template in PageSpeed Insights. Where I start: the 75th percentile of each metric on mobile, then the page group Search Console flags.
Google rates each URL on its own field data, or on its group of similar pages when the URL has too few visits, so a site passes one template at a time. Start with the templates that get the most visits: one fix in a template reaches every page built on it.
Real user monitoring (RUM) such as CoreDash measures your visitors' page loads and names the page, the device and the element behind a slow metric. Add it before you change anything, so you have a baseline.
Step 2: In what order do you fix the metrics?
Fix only the metrics that fail, and when LCP fails, start with the time to first byte (TTFB). According to the State of Web Vitals, TTFB is the largest of the four parts of LCP on phones for 67.6% of sites with an image as the LCP element. TTFB is no Core Web Vital: when LCP passes, leave the server alone.
- TTFB, when LCP fails: no front-end fix makes up for a server that takes seconds to answer.
- LCP: the metric that fails on the most sites.
- INP: the scripts you moved out of the page load for LCP stop blocking the first taps too.
- CLS: usually the quickest, a width and height on an image or a fixed height on an ad slot.
In the same data, 81.9% of sites have a good LCP on phones, against 91.8% for INP and 88.9% for CLS.
Step 3: How do you speed up a slow TTFB?
Time to first byte (TTFB) counts for the Core Web Vitals as the first part of LCP: the browser paints nothing before the HTML arrives. Good is 0.8 seconds or less at the 75th percentile. On most sites with a slow TTFB, the server builds the page again for every visitor. A page cache sends a stored copy instead, and the closer to the visitor it sits, the sooner the first byte arrives: the CDN first, then your host, then a plugin.
- Cache the HTML at the CDN. On Cloudflare, a Cache Rule for HTML that skips logged-in visitors and the cart (Cloudflare setup).
- Switch on a page cache at your host or in a plugin: WP Rocket, LiteSpeed Cache, or the Fast cache of this site's WP Core Web Vitals plugin. Test the page logged out.
- Find the visits that skip the cache: a login or cart cookie, or a query string such as the gclid on an ad click. In RUM their TTFB stays high.
- Remove redirects: each is a round trip before the HTML.
On the 149 sites that measure with CoreDash, in the 28 days up to 7 November 2026, phone page loads with an image LCP of 2.5 seconds or more spent 1.8 seconds on TTFB at the 75th percentile, against 0.47 seconds for image LCPs under 2.5 seconds.
The Time to First Byte guide covers the five parts of TTFB; Document request latency covers redirects and compression.
Step 4: How do you fix LCP?
LCP is four parts in a row: time to first byte, resource load delay (until the browser requests the image), resource load duration (the download) and element render delay (until it is painted). Fix the largest part; after the TTFB, that is usually an LCP image the browser finds late.

CoreDash Phase breakdown of image LCPs on mobile.
An image the browser finds late
An <img> in the HTML is requested while the HTML is still coming in. A photo with loading="lazy", a section background in CSS or a slide a script inserts waits for the layout, the stylesheet or the script. Take the first image out of lazy loading, use an image element instead of a background, and give it a high fetch priority:
<img src="/img/hero.webp" alt="..." width="1200" height="600" fetchpriority="high"> On a busy page, where the photo competes with dozens of scripts and stylesheets for the connection, fetchpriority="high" can make LCP up to 30% faster; Google measured 2.6 to 1.9 seconds on Google Flights. The fix fails when a lazy-load plugin moves the URL into data-src. A preload is only for a photo the HTML can't name, such as a background you can't change (LCP request discovery).
An image that waits to be shown
A downloaded photo that is still not on screen is held back: by an entrance animation, a slider that hides its slides until its script runs, scripts delayed until the first tap, or an A/B test's anti-flicker snippet. Switch off the first section's entrance animation and show the first slide in the HTML (LCP breakdown).
A text LCP, or a photo behind the stylesheets
A heading as the LCP element, or a photo that downloads before the CSS, waits for every stylesheet in the head; a heading often waits for the web font too. Keep each stylesheet under about 15 kB compressed, combine the tiny ones and drop @import; preload one or two fonts (Font display). Leave critical CSS off: the page is styled again when the rest of the CSS arrives, and inlined CSS is downloaded again on every page view.
A large image file
A smaller file usually helps least, so shrink it last: the size the screen needs, in WebP or AVIF with a srcset (optimize images). The Largest Contentful Paint guide covers each part.
Step 5: How do you improve INP?
Interaction to Next Paint (INP) is the Core Web Vital for responsiveness: the time from a click, tap or key press until the browser paints the next frame, for the slowest interaction of a visit or close to it. Good is 200 milliseconds or less at the 75th percentile. On phones it usually fails because a script is busy on the main thread when the visitor taps.
Take the slow interaction from your field data, then reproduce it in the Performance panel of Chrome DevTools with the CPU at 4x slowdown: record while you click and look at the tasks under the interaction. A long task (over 50 milliseconds) is marked red.

The Delay JavaScript settings in WP Rocket, Perfmatters and LiteSpeed Cache hold scripts back until the first interaction and then run all of them at once. Lighthouse never taps, so its score goes up; a real visitor taps the menu and waits for all of it. Leave those settings off for INP.
Start analytics, pixels and chat widgets after the load event instead, when the browser is idle, so the page's own content and scripts load before them:
window.addEventListener('load', () => {
const whenIdle = window.requestIdleCallback || ((cb) => setTimeout(cb, 1));
whenIdle(() => {
const script = document.createElement('script');
script.src = '/js/chat-widget.js';
document.head.appendChild(script);
});
}); Split your own long tasks, so the browser can handle a tap in between:
function yieldToMain() {
if (globalThis.scheduler?.yield) {
return scheduler.yield();
}
return new Promise((resolve) => setTimeout(resolve, 0));
}
async function runTasks(tasks) {
for (const task of tasks) {
task();
await yieldToMain();
}
} scheduler.yield() runs in Chrome from version 129 and Firefox from 142; Safari gets the fallback (yield to the main thread). The Interaction to Next Paint guide has the fixes per phase and platform.
Step 6: How do you stop layout shifts (CLS)?
Layout shifts stop when everything that arrives late has its space reserved. Aim for a CLS of 0: a CLS under 0.1 rates good and can still move a button under the visitor's thumb.
- Images: a width and height on every
<img>, so the browser reserves the height;width: autonext toheight: autoin the theme's CSS cancels it (images without a size). - Web fonts:
font-display: swapkeeps the shift, because the swap is the shift. A fallback font sized like the web font stops it, and so doesfont-display: optional(web fonts). - Ads and bars: a fixed height on the ad slot, and a newsletter or consent bar at the bottom or as a popup (ads and embeds).
<img src="hero.jpg" width="800" height="600" alt="..."> .ad-slot { min-height: 250px; }
.ad-slot iframe { display: block; } Without display: block the iframe sits on a line of text and the slot still grows a few pixels. The other causes are in the Cumulative Layout Shift guide.
Step 7: Did the fix reach your visitors?
Real user monitoring shows a fix from the next visits on. PageSpeed Insights and Search Console show the 75th percentile of the last 28 days, and that window moves one day at a time, so two weeks after a fix half of what they show is still the old site.

Check the page source first, logged out: a cache plugin or the CDN can serve the old page until you clear it. Then follow the metric per day in RUM, on mobile, for the template you changed. When it holds, click Start Tracking (Validate fix) on the issue in Search Console, which runs its own 28-day check (the 28-day wait).
Step 8: What makes the Core Web Vitals fail again?
A site that passes fails again after new code: a plugin, a theme update, a Shopify app, a new tag in Google Tag Manager. Track the Core Web Vitals per day in a RUM tracking tool such as CoreDash, with an alert by email or Slack when a metric gets worse: you see the change in days instead of a month later in Search Console.
In RUM, a sudden jump on one day points at a release; a slow climb over months is third-party scripts piling up, one tag at a time. After a large change, go through the Core Web Vitals checklist.
What do you change on WordPress, Shopify or Webflow?
On WordPress most fixes are a plugin or theme setting; on Shopify and Webflow the platform runs the server and its cache, and the theme, apps, images and custom code are yours.
WordPress
On WordPress, start with a page cache (Step 3), then the first image, and leave the Delay JavaScript settings off.
- The first image: WP Rocket's Optimize Critical Images, Perfmatters' Exclude Leading Images or LiteSpeed Cache's Viewport Images keep it out of lazy loading. WordPress itself gives the first large image
fetchpriority="high"; check that a large logo didn't take it. - Render delay: in Elementor, set Advanced, Motion Effects, Entrance Animation to None on the first section.
The plugins per metric are in the WordPress guide.
Shopify
- The first image: Dawn, Horizon and the themes built on them give the image in the first section
fetchpriority="high", so make the banner the first section. A hero an app builds with JavaScript starts late: use a theme section. - Render delay: where a theme's "Reveal sections on scroll" (Theme settings, Animations) starts the fade from invisible, switch it off.
- INP: in the theme editor under App embeds, switch the apps off one at a time and measure the slow tap after each.
- CLS: the
image_tagfilter writes the width and height; an app block such as review stars needs a height on its container.
More in the Shopify guide.
Webflow
- The first image: new images in Webflow lazy load by default. Select the hero image, set Load to Eager in its image settings, and add the custom attribute
fetchprioritywith the valuehigh. - Render delay: a page load interaction that sets the hero's initial state to hidden holds the photo back until the animation ends. Remove it from the first section.
Search Console still flags a group of pages after these steps, and your field data doesn't name the element or script behind it? In a Core Web Vitals power hour we open it together, find the template and the element that fail, and you leave with the fixes in order.

Need a faster site?
I'm Arjen, and I've been fixing slow sites for 17 years. If you're running into issues you can't fix yourself, send me your URL and let's have a chat.
Send me your URL
Why isn't our fix working?
Sometimes the CDN still serves the old HTML, or the fix went into the desktop template and mobile uses another one. Send me your URL and the problem, and I reply with a few times. I check your field data first, then we spend one hour on your site, and within a day you have my notes in writing. €350 excl. VAT.
Send me your URLNo developer to build the fix? I do the work myself, on a copy of your site.