[email protected] 0330 122 6522
Abstract dark editorial graphic of performance dials and a streamlined loading bar, illustrating the fixes that improve Core Web Vitals on a website

How to Improve Your Core Web Vitals (and When to Stop Patching)

To improve your Core Web Vitals, fix each metric at its usual cause. For LCP, shrink and prioritise the hero image and speed up the server. For INP, run less JavaScript. For CLS, reserve space for anything that loads late. Most of that is a few days’ work. If you have done it and still fail on mobile, the stack is the problem.

Where should you start?

Start with field data, find the one metric that is actually failing, and fix that first. Tuning all three at once is how people spend a month and move nothing.

If you need a refresher on what the three metrics are, our guide to Core Web Vitals in 2026 covers it. The short version of the targets, from Google’s Core Web Vitals documentation: LCP within 2.5 seconds, INP of 200 milliseconds or less, CLS of 0.1 or less, all assessed at the 75th percentile of real page loads.

Then do this, in order:

  1. Run your most important pages through PageSpeed Insights and read the field data section first. That is real visitors, not a simulation.
  2. Check the Core Web Vitals report in Search Console to see which groups of pages fail, and on which metric.
  3. Use Lighthouse only afterwards, to debug the specific problem.
  4. Test on mobile. It is nearly always the harder pass, and it is where most of your visitors are.

If the site is generally sluggish rather than failing one metric, why your website is so slow is the better place to begin.

How do you improve LCP?

Make the largest element on the page arrive sooner. Usually that means the hero image, and usually the cause is size, priority or a slow server.

Google’s LCP optimisation guide splits the load into four parts: time to first byte, resource load delay, resource load duration and element render delay. On a healthy page, roughly 40% sits in the server response and 40% in downloading the main resource. The two delay stages should be close to zero. That tells you where to look. If your delays are large, you are wasting time before the browser even starts.

Fix the image

  • Serve the right size. A huge photograph squeezed into a small slot is the most common LCP problem I see. Resize it to the size it is actually displayed at.
  • Use a modern format. WebP or AVIF are a fraction of the weight of the equivalent JPEG.
  • Never lazy-load the hero. Google is blunt about it: never lazy-load your LCP image, because it always adds unnecessary load delay. Lazy loading is for images below the fold.
  • Set fetchpriority="high" on it. One or two images at most. Mark everything high priority and nothing is.

Fix the server

If time to first byte is the largest slice, image work only gets you so far. Check for uncached dynamic pages, a slow database behind every request, or hosting that was chosen on price alone. Putting pages behind a CDN, or serving them as pre-built static HTML, removes most of that cost in one move.

Clear what blocks rendering

Stylesheets and scripts in the head hold the page back until they download. Inline the critical CSS, defer the rest, and ask of every script whether it needs to be there at all. Fonts belong here too: preload the one or two you use above the fold.

How do you improve INP?

Run less JavaScript, and run it in smaller pieces. INP is slow when the browser is busy at the moment someone taps, so the cure is a quieter main thread.

Google’s INP guidance comes down to a few habits:

  • Break up long tasks. A single chunk of script that runs for hundreds of milliseconds blocks every tap behind it. Split the work and yield back to the browser between pieces.
  • Keep event handlers light. Do the visual update first, then defer anything non-essential, such as analytics calls or saving state, to a later task.
  • Avoid forcing layout. Reading styles straight after changing them makes the browser recalculate layout on the spot.
  • Keep the DOM small. Very large pages are slower to render at load and again on every interaction.

The practical audit is simpler than the theory. List everything that loads on your key pages: tag manager containers, chat widgets, heatmap tools, sliders, cookie banners, social embeds. Ask what each one earns. Some will turn out to be there because someone added them once and nobody checked.

Every script you remove is an INP fix that never needs maintaining.

How do you fix layout shift (CLS)?

Reserve space before things arrive. Layout shift is almost always content that loads late and shoves everything else out of the way.

Google’s CLS guide lists the usual culprits and the fixes:

  • Images and video without dimensions. Add width and height attributes, or set a CSS aspect-ratio, so the browser holds the right space from the start.
  • Embeds, adverts and iframes. Give their container a minimum height sized to the smallest likely content, and keep the placeholder in place rather than collapsing it.
  • Web fonts swapping in. The text reflows when the real font lands. Preload critical fonts and use a fallback with adjusted metrics so the swap barely moves anything.
  • Banners injected above content. Cookie notices and promo bars that push the page down are a classic. Overlay them or reserve their space.
  • Animations. Animate with transform rather than properties like top or left, which force layout.

CLS is usually the quickest of the three to fix, because the causes are visible. Watch the page load in slow motion in DevTools and you will see what jumps.

Which fixes are quick wins and which mean a rebuild?

Quick wins are changes you can make without altering how the site is built. A rebuild trigger is a fix the platform will not let you make. Knowing which side you are on saves months.

Quick wins

  • Resize and compress images, convert to WebP or AVIF
  • Remove the lazy-loading attribute from the hero and prioritise it
  • Add image dimensions and reserve space for embeds
  • Preload one or two fonts and tidy the fallback
  • Remove unused scripts and widgets
  • Put a CDN and proper caching in front of the site

Rebuild triggers

  • Your theme or page builder ships a large amount of JavaScript and CSS on every page, and the structure cannot be changed without breaking it.
  • Plugins keep injecting scripts you cannot remove. Each fix reappears at the next update.
  • Server response is slow and you cannot change the hosting or the way pages are generated.
  • You have done every quick win and mobile still fails. At that point the remaining weight is the platform itself.

None of this is a case against any particular tool. It is a case against defaults. A site that ships its content as pre-built HTML with only the JavaScript a page needs starts most of these races already ahead. That is the reason we build on Astro, and why Astro SEO is mostly a story about getting out of the browser’s way.

If you are weighing it up, don’t take a vague feeling that the site is slow into the decision. Get a measured baseline first, so you know whether you are fixing a page or replacing a platform.

What does this look like on a real site?

On a real site, the biggest gain comes from removing weight rather than tuning it. A rebuild took the Hoc Paid Media homepage from a mobile LCP of 20.2 seconds to 3.1 seconds.

We rebuilt the site on Astro, and the Hoc Paid Media case study has the full before and after. Desktop LCP went from 2.2 seconds to 0.8 seconds, and desktop PageSpeed from 55 to 99. Mobile PageSpeed went from 34 to 86.

I will be straight about one thing: 3.1 seconds on mobile is better, but it is still above Google’s 2.5-second line for a good LCP. Rebuilding gets you most of the distance because the platform stops fighting you. The last stretch is still the tuning described above, and it is the part that never fully ends.

That is the honest shape of this work. Quick wins get a patched site to acceptable. A lighter stack gets you somewhere patching cannot. And you need a measured baseline before you can tell which one you need.

Free website audit

Get a measured baseline before you fix anything

Our free audit tests your key pages against LCP, INP and CLS using real-world data, then tells you plainly whether you are looking at a few quick wins or a rebuild. If a day of tuning will do it, we will say so. See what a rebuild can change in the Hoc Paid Media case study.

  • Your LCP, INP and CLS on mobile and desktop, in plain English
  • Which fixes are quick wins and which need a different stack
  • An honest recommendation, not a sales pitch
Get my free website audit

Frequently asked questions

How do I improve my Core Web Vitals?

Fix each metric at its usual cause. For LCP, compress and prioritise the hero image and speed up the server. For INP, cut the JavaScript the browser has to run, especially third-party scripts. For CLS, reserve space for images, embeds and fonts. Start with whichever metric fails in your field data, then retest.

What is the fastest way to improve LCP?

Find the largest element on the page, usually the hero image, and make sure it loads early. Serve it at the right size in a modern format, never lazy-load it, and set a high fetch priority on it. If the server itself responds slowly, no image tweak will fully fix it.

Why is my INP score bad?

Almost always because the browser is busy running JavaScript when someone taps. Tag managers, chat widgets, sliders and heavy page builders keep the main thread occupied, so interactions wait their turn. Remove what you do not need, defer the rest, and break up long tasks so the page can respond between them.

How long does it take to see Core Web Vitals improve?

Lab tools like Lighthouse show changes immediately. Field data takes longer, because field data is collected from real visits over a rolling period. Expect to wait a few weeks after a fix goes live before Search Console and PageSpeed Insights field data fully reflect it.

When should I rebuild my site instead of fixing Core Web Vitals?

Rebuild when the fixes you need are blocked by the platform itself: a slow theme you cannot restructure, plugins that inject scripts everywhere, or a server response you cannot improve. If you have done the quick wins and still fail on mobile, the stack is the constraint, and a lighter one is cheaper than endless patching.

Written by
Sam Wright · Founder, Aeonix

Sam Wright is the founder of Aeonix, an AI-first UK marketing agency. He writes about AEO, GEO and SEO, and what it takes to get found and cited now that buyers ask AI before they search Google. Less theory, more of what actually works.

Want this working for your business?

Start with a free audit, or talk to us about where to begin.