Website & Development
Improve Core Web Vitals: fixing LCP, INP and CLS
Copy for AI
Core Web Vitals optimization happens metric by metric, not with one setting.
You speed up loading (LCP), make the page more responsive (INP) and keep the layout stable (CLS).
The verdict: find the metric that fails on your most important pages, fix its cause, and confirm it in field data. Chasing a lab score of 100 is wasted effort.
Every metric has its own causes and therefore its own fixes.
Below: the fixes per metric, how to check they work, and which to tackle first.
Want to know first what LCP, INP and CLS measure and why Google factors them in? Read our explainer on what Core Web Vitals are. Here we go straight to the solutions.
What thresholds are you working towards?
An LCP under 2.5 seconds, an INP under 200 milliseconds and a CLS under 0.1.
Those are the limits Google labels as “good” in its Web Vitals guidance on web.dev.
| Metric | Measures | Good | Usual culprit |
|---|---|---|---|
| LCP (Largest Contentful Paint) | how fast the largest content block appears | under 2.5 s | heavy hero image, slow server |
| INP (Interaction to Next Paint) | how fast the page responds to a click, tap or keypress | under 200 ms | too much JavaScript |
| CLS (Cumulative Layout Shift) | how much the layout jumps while loading | under 0.1 | images and embeds without dimensions |
The largest block is usually your hero image or a large heading.
The glossary entries on LCP, INP and CLS give the short definitions.
INP replaced FID
INP officially replaced the older FID metric on March 12, 2024 as the responsiveness benchmark.
So older audits that still report FID are measuring the wrong thing.
The 75th percentile rule
Google judges these numbers on the 75th percentile of page loads, segmented by mobile and desktop, based on real visitor data.
In other words, at least three quarters of page loads need to hit a good score.
A nice lab measurement on your fast laptop says very little.
What counts is what your audience experiences on an average device and connection.
That’s why you always work from real data and never from a hunch.
How do you improve your LCP?
Make your largest, first-visible element lighter and faster to arrive.
In practice that’s almost always an image, or a heavy loading process standing in its way.
Where LCP time goes
Google splits LCP into four parts. Its LCP optimization guide suggests rough shares for a well-optimized page:
Google adds that these breakdowns “are guidelines, not strict rules”. Still, a large delay is a clear sign of waste.
What a real breakdown looks like
PageSpeed Insights shows the split for your own LCP element.
Here’s one of our articles, where the H1 is the LCP element:
PageSpeed Insights for our own largest contentful paint article, October 2026. The H1 in the first screen is the LCP element.
Almost all of that time is render delay, not server time.
For a text element, that usually means render-blocking CSS, fonts or scripts.
Four fixes, in order of impact
Concrete fixes:
- Compress images and use modern formats such as WebP or AVIF.
- Get fast hosting and a CDN close to your audience.
- Load your most important image with priority.
- Limit what blocks the first render: fonts, external scripts, unused CSS.
Fix 1: lighter images
A hero image of several megabytes is a classic LCP killer.
Also serve visuals at the right dimensions instead of scaling a large file down in the browser.
Fix 2: hosting and a CDN
A slow server keeps the browser waiting before anything appears at all.
Hosting close to your audience, usually Europe for our clients, makes a noticeable difference.
A CDN serves files from a location near the visitor.
Fix 3: priority, never lazy loading
With preloading or fetchpriority="high" you tell the browser this visual needs to arrive first.
Google’s advice: set it on the LCP image, but “setting a high priority on more than one or two images makes priority setting unhelpful”.
Lazy loading has no place on your hero, because it delays exactly what you need.
Fix 4: less that blocks the page
Heavy fonts, external scripts and unnecessary CSS that load first delay the moment your content becomes visible.
The less the browser has to do before the first render, the better.
Build it right the first time
Much of this gain is technical work under the hood.
It pays to get it right during the build or during a website redesign. Correcting it afterwards always costs more.
How do you make your INP better?
Cut back the amount and weight of JavaScript, so the page is free to respond to a click quickly.
A slow INP feels like a button that doesn’t react. Then you click again in irritation.
Four fixes for INP
What makes the difference:
- Prune third-party scripts. Trackers, chat widgets, A/B testing tools and pixels keep the main thread busy.
- Break up heavy work. Long, uninterrupted chunks of JavaScript block every response.
- Be critical of heavy page builders and plugins, especially on WordPress.
- Keep forms light. Your contact and quote forms are where interaction counts most.
Prune scripts first
Remove what you don’t really use and load the rest deferred.
For example, a chat widget nobody uses still loads its script on every page view.
Our glossary entry on JavaScript explains why that weight blocks interaction.
Split long tasks
By splitting tasks up, you give the browser room to respond to interactions in between.
A long task is any stretch where the main thread can’t react.
One big task beats ten small ones at blocking a click.
Find the slow interaction
Field data tells you INP is slow. It doesn’t tell you which click.
To find it:
- Open Chrome DevTools and go to the Performance panel.
- Record while you open the menu, filter a list or submit the form.
- Look for long tasks right after your click.
Lighthouse helps too. Its third-party audit lists which scripts take the most main-thread time.
That list is your pruning order. Start at the top.
Watch WordPress builders
A pile-up of plugins and a heavy theme builder can wreck your INP. Less is often faster here.
Protect your forms
A form that stutters at the moment someone wants to submit costs you a lead directly.
INP is the metric most strongly tied to how snappy your site feels.
A page that responds instantly keeps people in the flow towards your conversion point.
How do you fix CLS?
Give everything that takes up space a fixed spot in advance, so nothing jumps while the page loads.
Shifting content is annoying. Sometimes it literally costs a misplaced click.
Think of a quote button that drops just as someone taps it. They hit an ad or a link instead.
The four common causes
Each has a simple fix:
| Cause | Fix |
|---|---|
| Visuals without fixed dimensions | set a width and height on every image and video |
| Ads, embeds and banners | reserve a fixed block for content that loads later |
| Fonts that load late | load fonts smartly and choose a close fallback |
| Content injected at the top | plan space for bars and notices in advance |
Missing dimensions are by far the most common source of layout shift. The browser can’t reserve space it doesn’t know about.
Width and height still matter on responsive sites
Many teams drop the width and height attributes because the CSS makes images fluid anyway.
That’s the mistake. Browsers use those two attributes to calculate the aspect ratio before the file arrives.
So keep them in the HTML. With height: auto in your CSS, the image still scales, and the space is reserved.
For embeds such as a map, a video or a cookie notice, a reserved block means nothing gets pushed down.
When a web font appears late and the text reflows, your layout jumps. A good fallback style limits that.
Tip: pick a system fallback with similar letter widths. The closer the match, the smaller the jump when the web font swaps in.
It’s often the cheapest fix, and often forgotten
CLS is usually the cheapest of the three to repair. The fixes tend to be small and local.
Still, it gets forgotten, precisely because it barely stands out on a fast development machine.
Our own site is a good example.
In Search Console, layout shift, not load speed, is what keeps our mobile URLs out of the green:
Our own Search Console, Core Web Vitals on mobile, October 2026. A CLS issue above 0.1 keeps 349 mobile URLs at “needs improvement”.
One shared template issue affects every page built on it. Fix it once and all 349 URLs can move together.
How do you check whether your improvements work?
Measure before and after, and look at your real visitors, not just a lab test.
Otherwise you improve a number your audience never gets to see.
Field data: your source of truth
Google Search Console shows the Core Web Vitals for your entire site based on actual user data.
It also lists the URLs that need attention.
This is exactly what Google judges.
Per Google’s Core Web Vitals report documentation, it uses CrUX field data over the last 28 days.
Watch out: a URL group’s status is its worst metric. Two green metrics don’t save a red third.
PageSpeed Insights shows the same field data per URL at the top of its report:
PageSpeed Insights field data for customerimpact.be on mobile, October 2026. LCP passes at 1.9 s; CLS at 0.13 still needs work.
That’s the worst-metric rule in action: a good LCP, but CLS sets the verdict.
Lab data: for diagnosis
Tools like PageSpeed Insights and Google Lighthouse also run a test in a simulated environment.
They’re handy for seeing what slows a page down and for testing quickly.
But the numbers fluctuate, so treat them as a diagnosis, not a final verdict.
A loop that works
Run it in four steps:
- Measure the current state in field data.
- Push one fix.
- Wait a few weeks while new field data builds up.
- Check in Search Console whether the scores moved.
Field data lags because it’s built up over 28 days. Don’t expect a different number right after deploying.
Always test on mobile too. That’s where the experience is usually heaviest and where the most gain is.
Which fix do you tackle first?
The metric furthest from the threshold, on your most important pages, affecting the most visitors.
Not whatever is technically the most fun to solve.
The order we use
Three steps:
- Look at which pages deliver traffic and leads. Your homepage, your most important website development page and your strongest landing pages weigh more than a blog post buried deep in your site.
- Tackle the metric that’s in the red there. If your LCP sits at four seconds, image compression delivers more than one last CLS detail.
- Take the cheap wins along the way. Fixed dimensions and removing a few redundant scripts cost little and help immediately.
Don’t chase perfect scores
A page scoring 100 out of 100 that leads nobody to your form delivers nothing.
The goal is for visitors to stay, click through smoothly and convert.
Speed is a lever in that, not a finish line.
Our page speed glossary entry shows how speed and conversions connect.
The broader framework is in our guide to building a B2B website.
The short summary
You improve Core Web Vitals metric by metric:
- LCP: lighter images, fast hosting, priority on the hero.
- INP: less and lighter JavaScript.
- CLS: fixed dimensions so nothing jumps.
Work from field data in Search Console and use lab tools for diagnosis.
Start with the pages and metrics that affect the most traffic and leads.
We fix causes, not scores, and we aim at leads.
Core Web Vitals in the red? Ask us where your biggest gain is.
Free website scan
Enter your website and get an automatic scan within minutes, with concrete technical and SEO improvements. No sales pitch.
We only use your details for your scan. No spam, unsubscribe anytime.