Products SEO & GEO Agent Paid Ads Agent Website Agent Conversion Agent
How it works Pricing FAQ Blog Book a call

Improve Core Web Vitals: Advanced Fixes for LCP, INP and CLS

Updated · 6 min read

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 call

Which 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):

MetricMeasuresGoodWhere the time hides
LCP (Largest Contentful Paint)When the main image or headline shows2.5 seconds or lessFour parts: server, load delay, download, render
INP (Interaction to Next Paint)How fast a tap gets a visible responseUnder 200 millisecondsThree phases: input delay, processing, presentation
CLS (Cumulative Layout Shift)How much the layout jumpsUnder 0.1Specific 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).

PartWhat it isHealthy shareFixes
Time to First Byte (TTFB)Until the first byte of HTML arrivesAbout 40%CDN, page caching, remove redirects
Resource load delayFrom first byte until the main image starts downloadingUnder 10%Put the image in the HTML; `fetchpriority="high"`; no lazy loading
Resource load durationDownloading the image itselfAbout 40%Right size, AVIF or WebP, `srcset`, image CDN
Element render delayFrom download done to image on screenUnder 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).

PhaseWhat it isUsual causeFix
Input delayTap until your code startsLong tasks already running, often during page loadBreak up startup scripts; cut third-party tags
Processing durationYour event code runningToo much work in one handler; layout thrashingUpdate the screen first, defer the rest, yield
Presentation delayCode done until the next frame paintsLarge, complex DOMSmaller 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).

CauseFix
Images and video without size`width` and `height` attributes, or CSS `aspect-ratio`
Ads, embeds, iframes, banners injected lateA 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 backMake 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?

Keep learning

NextMobile page speed: make your site load fast on phonesWhat slows a small business site on phones: photos, chat and tracking scripts, hosting, redirects and fonts. How to test each one and fix it, in order.

Do it yourself

Crawlability checklist: make every page reachable by GoogleA crawlability checklist for a small business site: find orphan pages, robots.txt blocks, broken links, redirect chains and server errors, with free tools.

Ask us one question

One line is enough. We reply by email.

Sources

  1. Google Search Central: Understanding Core Web Vitals and Google search results
  2. web.dev: Web Vitals
  3. web.dev: Interaction to Next Paint becomes a Core Web Vital on March 12
  4. web.dev: Optimize Largest Contentful Paint
  5. web.dev: Optimize Time to First Byte
  6. web.dev: Optimize resource loading with the Fetch Priority API
  7. web.dev: Interaction to Next Paint (INP)
  8. web.dev: Optimize Interaction to Next Paint
  9. web.dev: Optimize long tasks
  10. web.dev: Optimize input delay
  11. web.dev: Optimize Cumulative Layout Shift
  12. web.dev: Cumulative Layout Shift (CLS)
  13. web.dev: Best practices for fonts
  14. web.dev: Back/forward cache
  15. PageSpeed Insights: About PageSpeed Insights