Improve Core Web Vitals: Advanced Fixes for LCP, INP and CLS
Short answer Fix only the metric your real-visitor data fails, and fix it by phase. Split LCP into server time, load delay, download time and render delay; split INP into input delay, processing and presentation; trace each CLS shift to its element. Never lazy-load the main image. FID advice is out of date: INP replaced it in March 2024.
Want help applying this to your business? Talk it through on a free 30-minute call.
Book a callWhich Core Web Vital should you fix first?
The one your real visitors fail. Check field data (Search Console's Core Web Vitals report or the top half of PageSpeed Insights), not the lab score. A page passes when 75% of visits meet all three targets (web.dev: Web Vitals).
Google's targets (Google Search Central):
| Metric | Measures | Good | Where the time hides |
|---|---|---|---|
| LCP (Largest Contentful Paint) | When the main image or headline shows | 2.5 seconds or less | Four parts: server, load delay, download, render |
| INP (Interaction to Next Paint) | How fast a tap gets a visible response | Under 200 milliseconds | Three phases: input delay, processing, presentation |
| CLS (Cumulative Layout Shift) | How much the layout jumps | Under 0.1 | Specific elements that move |
Advice that names FID (First Input Delay) is out of date. web.dev announced that INP would "replace FID on March 12" 2024, and FID was deprecated. FID "only measured the input delay of the first interaction" (web.dev: INP); INP times every tap through to the next paint.
Whether speed moves rankings is a separate question: see Core Web Vitals and Google ranking. This page is the fix list.
How do I improve LCP?
Break the LCP time into its four parts and shrink the biggest one. Chrome DevTools' Performance panel shows this breakdown for your page (web.dev: Optimize LCP).
| Part | What it is | Healthy share | Fixes |
|---|---|---|---|
| Time to First Byte (TTFB) | Until the first byte of HTML arrives | About 40% | CDN, page caching, remove redirects |
| Resource load delay | From first byte until the main image starts downloading | Under 10% | Put the image in the HTML; `fetchpriority="high"`; no lazy loading |
| Resource load duration | Downloading the image itself | About 40% | Right size, AVIF or WebP, `srcset`, image CDN |
| Element render delay | From download done to image on screen | Under 10% | Small or inlined critical CSS; render on the server |
Shares are from web.dev, which calls them "guidelines, not strict rules."
Server time. web.dev says a high TTFB "can make achieving a 2.5 second LCP challenging, or even impossible." Common causes: chains of redirects, visitors far from your server, and pages that can't be cached because of query parameters. Trust field TTFB here: lab tools usually test the final address, so they miss redirect time (web.dev: Optimize TTFB).
Load delay. The browser should find the main image in the first HTML it receives. If the image is a CSS background or set by JavaScript, preload it with a `rel="preload"` link tag. Add `fetchpriority="high"` to the likely LCP image, since browsers give images low priority by default. Fetch Priority works in Chrome and Edge 102+, Firefox 132+ and Safari 17.2+ (web.dev: Fetch Priority API).
"Never lazy-load your LCP image, as that will always lead to unnecessary resource load delay, and will have a negative impact on LCP." (web.dev: Optimize Largest Contentful Paint)
Lazy loading is right for images further down the page, and wrong for the top one. Many plugins lazy-load every image; exclude the hero.
Download time. Serve the image at the size it displays, in AVIF or WebP. An image CDN can do both automatically, but a separate image domain adds a connection cost.
Render delay. A large stylesheet in the page head blocks everything after it. Inline it only if it's small, because inlined CSS can't be cached. If your site builds the page with JavaScript in the browser, render it on the server so the image appears in the HTML.
One trap: compressing the image alone may not help. If the page is still waiting on CSS or scripts, web.dev notes the saved time just moves into render delay.
How do I improve INP?
Find the slowest tap, then see which of its three phases is long. INP reports roughly the worst interaction on a page; web.dev says it ignores one highest interaction for every 50, and scrolling and hovering don't count (web.dev: INP).
| Phase | What it is | Usual cause | Fix |
|---|---|---|---|
| Input delay | Tap until your code starts | Long tasks already running, often during page load | Break up startup scripts; cut third-party tags |
| Processing duration | Your event code running | Too much work in one handler; layout thrashing | Update the screen first, defer the rest, yield |
| Presentation delay | Code done until the next frame paints | Large, complex DOM | Smaller DOM |
Phases: web.dev: Optimize INP.
Long tasks. Any task over 50 milliseconds blocks the page from responding (web.dev: Optimize long tasks). Split them so the browser can handle a tap in between.
Yield. `scheduler.yield()` hands control back to the browser mid-task. It runs in Chrome and Edge 129+ and Firefox 142+, not Safari, so keep a `setTimeout` fallback (web.dev: Optimize long tasks). In a click handler, do the visible update first and push analytics or saving to after the next frame.
Third-party scripts. Chat widgets, trackers and booking embeds run on the same main thread as your code. Yielding doesn't protect you from them: web.dev: Optimize input delay notes their tasks can still slip in between yours. Removing a tag is often the only fix you control.
Layout thrashing. Changing a style and then reading a size in the same task forces the browser to recalculate layout immediately. Batch your reads, then your writes.
How do I improve CLS?
Find which element moves, then reserve its space. Lighthouse lists the shifting elements; DevTools' Performance panel has a "Layout shift culprits" insight (web.dev: Optimize CLS).
| Cause | Fix |
|---|---|
| Images and video without size | `width` and `height` attributes, or CSS `aspect-ratio` |
| Ads, embeds, iframes, banners injected late | A fixed box with `min-height` before they load |
| Animating `top` or `left` | Animate `transform` instead; it can't move other elements |
| Web fonts swapping in | `font-display: optional`, preload key fonts, `size-adjust` on the fallback |
| Shifts after the visitor leaves and comes back | Make pages eligible for the back/forward cache |
Sources: web.dev: Optimize CLS; web.dev: Best practices for fonts.
Fonts. `font-display: swap` keeps text visible, but the swap itself can shift the layout (web.dev: Best practices for fonts). `optional` uses the web font only if it's ready at first layout, so nothing re-flows. If you keep `swap`, match the fallback font's size with `size-adjust`.
Back/forward cache. When a visitor taps back, a cached page returns exactly as they left it, with no new shifts. web.dev's top rule: "never use the unload event." Also avoid `Cache-Control: no-store` on the page itself.
Why lab and field disagree. Lighthouse measures one page load. Field CLS covers the whole visit, including shifts while scrolling (web.dev: Optimize CLS). Shifts within 500 milliseconds of a tap don't count, so an accordion opening on click is fine.
Example
Illustrative cases, not measured results.
A roofer's homepage at 4.1 seconds LCP
The breakdown shows 2.2 seconds of load delay: a plugin lazy-loads the hero photo. Excluding it from lazy loading and adding `fetchpriority="high"` puts the photo in the first downloads. Server time, already near 40%, is the next target.
A dental office with 450-millisecond INP
The slow tap is "Book now." The handler opens the form, then sends three tracking events before the browser paints. Showing the form first and sending events after the next frame cuts the processing phase.
A law firm at 0.24 CLS
DevTools shows two culprits: a cookie banner pushed in at the top and a font swap in the headline. A reserved banner box and `font-display: optional` stop both shifts.
FAQ
Does lazy loading improve Core Web Vitals?
For images further down the page, it saves data. For the main image at the top, it makes LCP worse every time, according to web.dev.
Do I still need to fix FID?
No. INP replaced FID as a Core Web Vital on March 12, 2024. Measure and fix INP.
Can I make these fixes on Wix or Squarespace?
Partly. You control images, embeds and add-ons, not the server or theme code. See Wix, Squarespace or WordPress for SEO.
How long until the fix shows in field data?
PageSpeed Insights field data covers the previous 28 days, so expect up to four weeks before a fix fully shows.
Different for you?
- Fast site, still no calls: website not getting leads.
- Not sure speed matters for ranking: Core Web Vitals and Google ranking.
- Need to find the failing page groups first: Google Search Console for a small business.
- Want a fast site built and kept fast: Website Agent.