Core Web Vitals Fixes That Actually Move the Needle in 2026

The fixes that still matter in 2026 are LCP image priority, layout shift from unsized media, and INP from heavy JavaScript. Add fetchpriority="high" to your hero image, stop lazy-loading it, set explicit width and height, and cut third-party scripts. That covers most of it.
Part of the complete web development guide.
On this page
- 1. Fix LCP with fetchpriority, not lazy-loading
- 2. Stop blocking the main thread with third-party scripts
- 3. Kill layout shift at the source
- 4. Ship less JavaScript, not faster JavaScript
- 5. Measure in the field, not just the lab
- What I’d do first if it were my site
- FAQ
- Do Core Web Vitals still affect rankings in 2026?
- What’s a good LCP score?
- Can I fix Core Web Vitals without touching my code?
Most Core Web Vitals advice floating around is either three years stale or written by someone who never shipped a site. The metrics changed, the tooling changed, and a few of the “fixes” people still repeat will do nothing for your scores. Here’s what I actually reach for when I’m auditing a site in 2026, roughly in the order I check them.
One note up front: a fast site with bad content still loses. Core Web Vitals is a tiebreaker, not a strategy. Fix the big stuff, then stop obsessing over the last two points.
1. Fix LCP with fetchpriority, not lazy-loading
The single most common LCP mistake I see is a hero image that’s lazy-loaded. The browser has no idea it needs that image until it parses far enough down the page, so it sits there doing nothing while your LCP clock runs. Lazy-loading is for images below the fold. Your hero is not below the fold.
Mark the hero image as high priority and preload it:
<link rel="preload" as="image" href="/hero.avif" fetchpriority="high">
<img src="/hero.avif" width="1200" height="630"
fetchpriority="high" decoding="async" alt="...">
Notice there’s no loading="lazy" on that image. That’s intentional. Also set explicit width and height so the browser reserves space and doesn’t shift your layout (that’s CLS, which we’ll get to).
Format matters too. AVIF is well supported now and typically beats WebP by 20 to 30 percent on file size for photos. Serve AVIF with a WebP fallback if you care about very old browsers, which in 2026 you probably don’t need to.
2. Stop blocking the main thread with third-party scripts
Nine times out of ten, INP (Interaction to Next Paint) problems are third-party scripts. Chat widgets, heatmap tools, ad tags, that one analytics snippet somebody added in 2021 and forgot about. They all compete with your code for the main thread.
Open DevTools, go to the Performance panel, and record yourself clicking around. Look for long tasks (anything over 50ms) in the main thread. Then check the Coverage tab to see how much of your JavaScript never runs.
Two fixes that usually help:
- Load non-critical scripts with
deferor, better, after the page is interactive. - Break up long tasks in your own code so the browser can respond to input between chunks.
// Yield to the browser between chunks of work
async function processItems(items) {
for (const item of items) {
doWork(item);
// Give the main thread a chance to handle input
await new Promise(r => setTimeout(r, 0));
}
}
If you have a chat widget loading synchronously in the head, that’s your INP problem. Move it or kill it.
3. Kill layout shift at the source
CLS is almost always one of four things: images without dimensions, ads or embeds without reserved space, web fonts that swap and reflow text, or content injected above the fold after load.
Reserve space for anything that loads late:
/* Reserve space for an ad slot so it doesn't shove content down */
.ad-slot {
min-height: 250px;
contain: layout;
}
For fonts, use font-display: swap with a fallback that’s metrically close to your web font. Or self-host and preload the font file so the swap window is tiny. Google Fonts is fine, but self-hosting removes a connection to a third-party domain and gives you control over caching.
4. Ship less JavaScript, not faster JavaScript
You can micro-optimize a 2MB bundle all day and still lose to a 200KB one. The most effective performance work is deleting code, not tuning it. I’ve cut LCP in half on more than one project just by removing a UI library that was pulling in a component the site used once.
Practical steps:
- Run a bundle analyzer and look at what’s actually shipped to the browser.
- Replace heavy dependencies with native browser APIs where you can.
fetch,IntersectionObserver, and CSS now cover a lot of what used to require libraries. - Code-split routes so a visitor on the homepage isn’t downloading your checkout flow.
If you’re on WordPress, the same logic applies. Every plugin that enqueues a stylesheet or script on every page is a tax on every visitor. Audit them the way you’d audit anything else.
5. Measure in the field, not just the lab
Lighthouse scores are a starting point, not a grade. They run on a simulated connection on one machine and tell you what could happen. What actually matters is what real users on real devices experience, and that’s field data from the Chrome UX Report.
Check your field data in Search Console under Core Web Vitals, or pull it directly from the CrUX API. Pay attention to the 75th percentile, not the average. If 25 percent of your visitors are having a bad time, you have a problem even if the average looks fine.
Mobile field data is the one that counts. Most of your traffic is on phones, often on mediocre connections, and that’s where the fixes above pay off most.
What I’d do first if it were my site
If you only have an afternoon: un-lazy-load the hero image, add width and height to every image, and check what third-party scripts are loading on page load. That’s maybe two hours of work and it moves the needle more than anything else on this list.
If you want it done properly, performance work overlaps heavily with custom web development, since the fixes have to live in your build, not in a plugin you bolt on afterward. And it overlaps with Long Island SEO, because Core Web Vitals is a ranking input and slow sites get crawled less. I’m based out of Commack, so a lot of what I do is cleaning up sites that were built fast and never tuned. That’s fine. Most sites start that way.
FAQ
Do Core Web Vitals still affect rankings in 2026?
Yes, but they’re a tiebreaker, not a primary signal. Google uses them to separate pages of roughly equal relevance. A slow page with great content can still outrank a fast page with thin content. Fix your vitals, then focus on the content.
What’s a good LCP score?
2.5 seconds or less at the 75th percentile of real users. Under 4 seconds is “needs improvement,” and over 4 seconds is poor. Measure in the field, not in Lighthouse, because lab scores don’t reflect your actual visitors.
Can I fix Core Web Vitals without touching my code?
Sometimes. Caching, image optimization, and a CDN can help without a code change. But layout shift, render-blocking scripts, and oversized bundles usually need real changes in your theme or build. A plugin can mask the problem; it rarely solves it.


