TL;DR: Interaction to Next Paint (INP) replaced First Input Delay as an official Google Core Web Vital in March 2024 — and as of November 2026, it remains the single metric most websites fail. A poor INP score means users experience sluggish, unresponsive pages, Google ranks you lower, and conversions quietly bleed out. It is also one of the hardest metrics to diagnose and fix without deep performance expertise.
What Is INP — and Why Does It Replace FID?
First Input Delay (FID) only measured the delay before the browser started processing your first user interaction. It was a narrow, forgiving metric. Interaction to Next Paint (INP) is far stricter: it measures the full duration from any user interaction — a click, tap, or keyboard event — to the moment the browser actually renders a visible response on screen. And it tracks the worst interaction across the entire page session, not just the first one.
The scoring thresholds Google uses today:
INP Score Thresholds (milliseconds)
The chart above shows relative “risk zones.” In practice, the gap between 200 ms and 500 ms is enormous from a user perception standpoint: anything beyond ~300 ms starts to feel broken. Anything above 500 ms and users assume the site has crashed.
The Sobering State of INP in 2026
Despite two and a half years as an official ranking signal, Chrome UX Report (CrUX) field data from Q4 2026 continues to tell an uncomfortable story: roughly 40% of websites tracked in CrUX still score in the “Needs Improvement” or “Poor” bands for INP. That’s a significantly worse pass rate than LCP or CLS.
Why? Because INP is runtime performance — it happens inside the browser, in real users’ sessions, on real devices. Lab tools like Lighthouse can estimate it, but INP only truly surfaces in field data. A site that scores 100 on a Lighthouse lab test on a developer’s M3 MacBook can still return a poor INP score for 70% of real users on mid-range Android phones with throttled CPUs.
Lighthouse and PageSpeed Insights lab mode run on emulated hardware. INP is a field metric — it only appears accurately in real-user monitoring (RUM) data via CrUX or tools like web-vitals.js. If you’re only looking at lab scores, you are flying blind.
What Actually Causes a Poor INP Score
Understanding the culprits is the first step — but diagnosing which of these applies to your site requires real user data, profiling, and expertise. The main drivers of high INP include:
- Long JavaScript tasks on the main thread. Any task exceeding 50 ms blocks the browser from responding to interactions. Heavy JS frameworks, bloated page builders (hello, some WordPress setups), and monolithic bundles are prime offenders.
- Render-blocking third-party scripts. Analytics, chat widgets, ad networks, and marketing pixels all compete for main-thread time. Each one can spike INP dramatically — and they behave differently per user, per geography, per network.
- Inefficient event handler logic. Event listeners that do too much work synchronously — large DOM updates, layout thrashing, synchronous fetches — directly inflate interaction latency.
- Excessive DOM size. Pages with 1,500+ DOM nodes take longer to style, layout, and paint after each interaction. WordPress themes with deeply nested shortcodes and page builders are notorious for this.
- Input delay from task queuing. If the main thread is already busy (say, running a heavy script) when a user clicks, the browser queues the event. That queuing delay alone can push INP past 500 ms.
What Poor INP Costs You: Rankings and Revenue
Google’s Page Experience ranking signals use field data from CrUX, not lab scores. If your site fails INP in real-user data for the majority of your mobile visitors, you are receiving a direct ranking penalty relative to competitors who pass. In competitive verticals — e-commerce, local services, SaaS, healthcare — that ranking difference translates directly to traffic and revenue lost.
The conversion angle is equally stark. Research from Google and multiple large-scale studies consistently shows that every 100 ms of additional interaction latency can reduce conversion rates by 1–7%, depending on the action type. A checkout button that takes 600 ms to visually respond trains users to distrust the site. Many simply leave.
INP on WordPress: A Specific Challenge
WordPress powers over 43% of the web in 2026, and it has a specific INP vulnerability profile. Many WordPress sites rely on:
- Page builders (Elementor, Divi, WPBakery) that generate enormous DOM trees and load significant inline JS
- Plugin stacks with 30–60+ active plugins, each registering its own scripts and event listeners
- WooCommerce cart/checkout flows that are notoriously main-thread-heavy
- Theme frameworks that bundle jQuery-dependent libraries alongside modern JS
None of these are impossible to fix, but the fix is never as simple as “install a caching plugin.” Genuine INP improvement on a complex WordPress site requires a thorough WordPress technical audit to map every JS task, every render-blocking resource, and every interaction path — before any optimization work begins.
Don’t confuse a green Lighthouse score with a passing INP. Run your URL through PageSpeed Insights and look at the ‘Field Data’ panel (powered by CrUX). That’s what Google’s ranking algorithm actually sees. If field data is missing, set up real-user monitoring — it’s the only honest view of your INP.
Why INP Is So Hard to Fix Without Expertise
Fixing LCP is relatively mechanical: optimize images, upgrade hosting, improve TTFB with a CDN. Fixing CLS means adding explicit dimensions to media. But INP improvement is an exercise in JavaScript profiling, task scheduling, and architectural decisions that often touch the core of how a site is built.
Common INP fixes require deep knowledge of:
- Code-splitting and lazy loading — breaking large JS bundles so only needed code runs per interaction
- Scheduler API and
requestIdleCallback— deferring non-critical work away from user interaction paths - React / Vue / Alpine rendering optimization — avoiding unnecessary re-renders triggered by state updates on interaction
- Third-party script quarantine — loading analytics and marketing tools in ways that don’t pollute the main thread
- Long Task breaking with
yieldpatterns — decomposing synchronous 200 ms+ tasks into smaller async chunks
Each of these is a specialist skill. Getting them wrong — or applying them in the wrong order — can introduce regressions in functionality or even worsen other Core Web Vitals. It’s precisely why teams that try to self-diagnose INP with surface-level tools often spend weeks and see no field-data improvement at all.
At Totaliweb, our guaranteed PageSpeed & performance service includes full INP profiling using real-user monitoring, interaction traces from Chrome DevTools’ Performance panel, and Long Task analysis — not just a Lighthouse score. We’ve resolved INP regressions on complex WooCommerce builds and high-traffic Next.js apps alike, as documented in our case studies.
The INP Opportunity No One Is Talking About
Here’s the contrarian upside: because INP is still so widely failed, it represents a genuine competitive performance gap. If your site passes INP while your top 3 competitors fail, you hold a durable ranking advantage backed by a real quality signal — not keyword tricks or link schemes.
In November 2026, with AI-generated content flooding search results and Google leaning harder on page experience signals to differentiate quality, technical performance is not a “nice to have.” It is core infrastructure for search visibility.
Open PageSpeed Insights (pagespeed.web.dev), paste your URL, and scroll to ‘Field Data.’ If your INP shows as ‘Needs Improvement’ or ‘Poor’ — or if field data is absent — you are likely losing ranking positions and conversions every single day without knowing it.
Key Takeaways
- INP is the Core Web Vital most sites fail in 2026, yet it carries direct ranking weight in Google’s Page Experience signals.
- Unlike lab metrics, INP only tells the truth in real-user (CrUX) field data — which is exactly what Google uses.
- WordPress sites face heightened INP risk due to plugin bloat, page-builder DOM size, and JS-heavy themes.
- Poor INP is simultaneously a ranking penalty and a conversion killer — the two things that most directly impact business revenue from organic search.
- Genuine INP remediation is architectural and runtime-level work, not a plugin fix — it requires profiling, profiling, and more profiling.
Frequently asked questions
What is a good INP score in 2026?
Google considers an INP score of 200 milliseconds or less as 'Good.' Scores between 201–500 ms 'Need Improvement,' and anything above 500 ms is rated 'Poor.' The 'Good' threshold is measured at the 75th percentile of real-user interactions, meaning 75% of your users' interactions must complete within 200 ms.
Does INP directly affect Google rankings?
Yes. INP is an official Core Web Vital and part of Google's Page Experience ranking signals. Google uses field data from the Chrome UX Report (CrUX) — not lab scores — so a poor INP in real user sessions can directly suppress your rankings, particularly on mobile.
Why do WordPress sites often fail INP?
WordPress sites frequently fail INP due to heavy page builders generating large DOM trees, stacked plugins each loading their own JavaScript, jQuery-dependent themes, and WooCommerce checkout flows that perform significant synchronous work on the browser's main thread. These factors combine to create long tasks that delay visible response to user interactions.
Can a caching plugin fix a poor INP score?
No. Caching plugins improve server response time (TTFB) and can help LCP, but INP is a client-side, runtime metric. It reflects how quickly the browser responds to user interactions after the page has already loaded. Fixing INP requires JavaScript optimization, task scheduling improvements, and often architectural changes to how the page renders.
How is INP different from FID (First Input Delay)?
FID only measured the delay before the browser began processing the very first user interaction on a page. INP is broader and stricter: it measures the full latency from input to visual response for every interaction during the session, then reports the worst-case result. INP officially replaced FID as a Core Web Vital in March 2024.
Le pagine lente fanno perdere vendite. Ottimizziamo server, cache, immagini e codice perché il tuo sito WordPress carichi veloce e resti stabile sotto traffico — con punteggi prima/dopo misurabili.
Da €149 · Max 3 giorni
Richiedi un preventivo gratuitoEsplora i nostri casi studio →
Unisciti alla conversazione
Domande, idee, esperienze — leggiamo tutto.
Ancora nessun commento — condividi per primo la tua opinione.