You tap "Add to basket" and nothing happens. You tap again. A second later, two items appear. That frustrating lag is what Interaction to Next Paint (INP) measures, and it's the Core Web Vital that most websites fail on phones.

INP replaced First Input Delay as a Core Web Vital in March 2024, and the thresholds haven't changed since. Here's what it means and how to fix it.

What INP measures

INP looks at the clicks, taps and key presses a visitor makes during a visit and measures how long it takes from each interaction until the screen visibly updates. It reports roughly the slowest interaction (ignoring rare outliers).

INP (75th percentile of real visits)Rating
200 ms or lessGood
200–500 msNeeds improvement
Over 500 msPoor

For context on the other two Core Web Vitals (LCP and CLS), see Core Web Vitals in 2026.

Where to find your INP

  • Google Search Console → Core Web Vitals: groups of URLs with poor or improving INP, from real Chrome users.
  • PageSpeed Insights: field data for a URL or the whole origin (top section), plus lab diagnostics.
  • Chrome DevTools → Performance panel: record yourself interacting and see exactly what blocks the main thread.
  • Real user monitoring tools for detailed breakdowns by page and interaction.

Lighthouse alone can't measure INP because it doesn't interact with the page; it reports Total Blocking Time as a rough proxy.

Why INP is slow

Every interaction has three parts:

  1. Input delay: the browser is busy with other work and can't start handling your tap.
  2. Processing time: your event handlers (JavaScript) run.
  3. Presentation delay: the browser recalculates layout and paints the update.

Most poor INP comes from too much JavaScript running on the main thread.

Common causeTypical example
Heavy third-party scriptsChat widgets, A/B testing tools, tag managers, ad scripts
Large JavaScript bundlesWhole libraries loaded for small features
Long tasks during loadHydration of a big page while the user tries to tap
Expensive event handlersFiltering hundreds of products on every keystroke
Huge DOMThousands of elements making layout slow
Layout thrashingCode reading and writing layout repeatedly

How to fix it

1. Audit third-party scripts

List every script your site loads. For each, ask: do we still use it? Can it load later or only on pages that need it? Removing two unused marketing scripts often helps more than any code change.

2. Break up long tasks

Any task over 50 ms blocks interactions. Split heavy work into smaller chunks and yield to the browser between them, for example with scheduler.yield() where supported, or setTimeout as a fallback.

3. Respond first, work later

Update the UI immediately (show a spinner, change the button state), then do the heavy work. Users perceive responsiveness from that first visual change.

4. Debounce input-heavy features

Search boxes and filters shouldn't run full calculations on every keystroke. Wait for a short pause, or move work to a web worker.

5. Reduce JavaScript

  • Remove unused code and dependencies.
  • Load features only when needed (code splitting, dynamic imports).
  • Prefer server-rendered HTML for content that doesn't need interactivity. Modern frameworks like Next.js render most content on the server by default.

6. Keep the DOM lean

Paginate or virtualise long lists, remove hidden markup you don't need and simplify deeply nested layouts.

7. Use CSS for animations

Animate transform and opacity rather than properties that trigger layout. Consider CSS view transitions for page changes instead of heavy JavaScript animation libraries.

8. Watch hydration on frameworks

On JavaScript frameworks, the page can look ready before it's interactive. Reduce what needs hydrating, and avoid large client components above the fold.

Platform-specific tips

PlatformQuick wins
ShopifyRemove unused apps (their scripts often stay), audit theme JavaScript, limit live chat and pop-up apps
WordPressReduce plugins, disable scripts on pages that don't need them, avoid heavy page builders for key pages
Wix / SquarespaceLimit third-party embeds and apps; keep pages simpler
Custom React / Next.jsServer components, code splitting, memoisation, profiling expensive renders

Why it matters beyond rankings

Slow responses feel broken. People double-tap, add duplicate items, abandon forms and leave. Improving INP usually improves conversion on mobile, where most traffic and most problems are. Read UX mistakes killing your conversion rate.

A quick checklist

  1. Check INP in Search Console and PageSpeed Insights (field data).
  2. Record slow interactions in Chrome DevTools on a mid-range phone or with CPU throttling.
  3. Remove or delay unnecessary third-party scripts.
  4. Break up long tasks and respond visually first.
  5. Debounce search and filters.
  6. Cut unused JavaScript and lazy-load features.
  7. Simplify large DOMs and long lists.
  8. Re-test after 28 days of field data.

The short version

INP measures how quickly your site visibly responds to clicks, taps and typing; 200 ms or less is good. Poor INP usually comes from too much JavaScript on the main thread, especially third-party scripts. Remove what you don't need, break up long tasks, update the UI before heavy work, debounce inputs and keep the page lean.

Want your site's speed fixed properly? Our web development team builds and tunes fast websites, or start with a free AI Website X-Ray that tests phone and desktop speed.