Most business owners have heard the phrase “Core Web Vitals” by now. Far fewer understand what changed in 2024, why it still matters in 2026, and more importantly, why their website might be losing ground in Google rankings because of a metric they have never even looked at.

That metric is INP: Interaction to Next Paint. It replaced First Input Delay (FID) as an official Google ranking signal in March 2024, and based on data from the Chrome User Experience Report (CrUX), a significant proportion of websites across every industry still fail it.

This post explains what INP is, why the older FID metric was not cutting it, and what you can do in practical terms to improve your score and protect your rankings.

FID vs INP: What Changed and Why It Matters

First Input Delay measured only the delay before a browser began processing the very first interaction a user made with a page, typically the first click or tap. It was easy to pass because it only captured one moment. A site could have terrible responsiveness throughout most of a user session and still score fine on FID.

Interaction to Next Paint is far more demanding. It measures the full latency of all interactions during a page visit and reports the worst one. Every click, every tap, every keyboard entry is evaluated. The metric captures the delay from when a user initiates the interaction to when the browser actually paints the visual response. If a user clicks a menu, fills out a form, or taps an accordion, and the page takes 300 milliseconds to respond visually, that is a poor INP score.

Google’s own thresholds are clear:

• Under 200ms: Good
• 200ms to 500ms: Needs Improvement
• Over 500ms: Poor

According to the HTTP Archive’s 2025 Web Almanac, roughly 35% of mobile pages fail to meet the “Good” INP threshold. On mobile, the problem is worse because JavaScript execution on lower-powered devices is slower, and many websites are built with desktop hardware in mind.

Why Core Web Vitals Are Still a Ranking Factor in 2026

There is some debate in the SEO community about how much weight Core Web Vitals actually carry. The honest answer is that Google has never published exact weighting, and they probably never will.

What is not debatable is that page experience signals are part of the ranking algorithm, that Google’s documentation explicitly confirms this, and that the businesses investing in performance consistently outperform those who treat speed as an afterthought.

A 2024 study by DebugBear analysed 1,700 websites across multiple industries and found a meaningful correlation between passing all three Core Web Vitals (LCP, INP, and CLS) and ranking in the top five for competitive keywords. Correlation is not causation, but combined with Google’s official stance, the case for fixing your vitals is strong.

There is also a commercial argument that has nothing to do with Google. A study by Deloitte found that improving mobile site speed by just one second increased conversions by up to 27% for retail brands. Portent’s research, consistently updated through 2025, shows that a page loading in 1 second converts 3x better than one loading in 5 seconds. Your ranking is one thing. Your ability to turn visitors into customers once they arrive is another.

Breaking Down the Three Core Web Vitals

Largest Contentful Paint (LCP) This measures how long it takes for the largest visible element on the page to fully load. For most websites this is a hero image, a large heading, or a video thumbnail. Google’s “Good” threshold is under 2.5 seconds. The most common culprits for poor LCP are unoptimised images, render-blocking resources, slow server response times, and no CDN in place.

Interaction to Next Paint (INP) As described above, this is now the critical responsiveness metric. Long JavaScript tasks are the primary cause of poor INP scores. When the browser’s main thread is busy executing a large JS bundle, it cannot respond to user interactions, causing the visual delay that INP captures. Third-party scripts, analytics tools, chat widgets, and ad networks are frequent offenders.

Cumulative Layout Shift (CLS) This measures visual stability. A page with a poor CLS score jumps around as it loads: images expand, fonts swap, ads push content down. The threshold for “Good” is under 0.1. The fix is usually straightforward: give images and video elements explicit width and height attributes, and avoid injecting content above existing content after the page loads.

Diagnosing Your Site: Tools Worth Using

Before you fix anything, you need to know where you actually stand.

PageSpeed Insights (pagespeed.web.dev) is the obvious starting point. It shows both lab data (a simulated test) and field data from real users who have visited your site via Chrome. The field data is what Google actually uses for ranking purposes.

Google Search Console has a dedicated Core Web Vitals report under the Experience section. It shows which URLs are failing, which need improvement, and which are in the green zone. This is the closest thing to seeing how Google itself views your performance.

DebugBear (debugbear.com) offers more granular diagnostics than PageSpeed Insights and tracks performance changes over time. Particularly useful for identifying which third-party scripts are adding to your INP score.

Chrome DevTools with the Performance panel lets developers record interaction traces and pinpoint exactly which JavaScript tasks are causing main-thread blocking. If you have a development team, this is the tool for root cause analysis.

10 Practical Fixes to Improve Your Core Web Vitals

1. Audit and remove unused JavaScriptRun your site through PageSpeed Insights and look at the “Remove Unused JavaScript” recommendation. Most websites carry significant JS weight that is never executed. Tools like Webpack Bundle Analyser can help developers identify what to cut.
2. Break up long JavaScript tasksTasks over 50ms block the main thread and contribute directly to poor INP. Refactor large synchronous functions into smaller asynchronous chunks. The scheduler.yield() API, now widely supported, makes this easier.
3. Load third-party scripts asynchronouslyEvery third-party script, from Google Analytics to live chat widgets, adds to your main thread workload. Load them with the asyncor defer attribute wherever possible. Consider loading non-critical tools only after the user interacts with the page.
4. Use a Content Delivery Network (CDN)A CDN serves your assets from servers geographically closer to each user, cutting the time to first byte and improving LCP. Cloudflare, BunnyCDN, and Fastly are all solid options for small to mid-size businesses.
5. Optimise and properly size imagesConvert images to WebP or AVIF formats, serve appropriately sized images for each device, and use the loading=”lazy”attribute for below-the-fold images. Do not lazy-load your hero image; that is a common mistake that hurts LCP.
6. Preload your LCP elementAdd a <link rel=”preload”>tag for your largest above-the-fold image. This tells the browser to fetch it early, before it would otherwise discover it in the HTML.
7. Self-host fontsGoogle Fonts adds an external request to your critical render path. Self-hosting your fonts and using font-display: swapeliminates that dependency and reduces layout shift from font swaps.
8. Set explicit dimensions on media elementsAdd widthand height attributes to every <img> and <video> tag. This allows the browser to reserve space for them before they load, which directly reduces your CLS score.
9. Minimise CSS that blocks renderingInline only the critical CSS needed for above-the-fold content and defer everything else. Tools like Critical CSS (GitHub: addyosmani/critical) can automate this step.
10. Review and audit your WordPress pluginsIf your site runs on WordPress, excessive plugins are very often the main performance bottleneck. Run a plugin audit, remove anything you no longer actively use, and replace heavy plugins with leaner alternatives.

The Business Cost of Ignoring This

A website that loads slowly and responds sluggishly does two things to your business. It tells Google your site is not worth serving to users in top positions. And it tells your visitors, through their actual experience of using the site, that they might be better off somewhere else.

The 100ms rule is worth knowing about here. Research from Google found that every 100ms increase in page load time reduces conversions by approximately 7%. For an e-commerce business turning over £500,000 a year in online revenue, a 500ms slowdown is a potential £35,000 annual loss. For service businesses, the impact shows up in bounce rates and enquiry form completions.

Performance is not a technical nicety. It is a commercial decision.

Is your website failing Core Web Vitals? KuBoz Digital offers a free performance audit that tells you exactly where you stand and what it will cost to fix it.

Our development team builds and optimises websites that pass all three Core Web Vitals, load fast on every device, and convert better as a result. Start with a free audit or get in touch at info@kuboz-digital.co.uk.