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 less | Good |
| 200–500 ms | Needs improvement |
| Over 500 ms | Poor |
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:
- Input delay: the browser is busy with other work and can't start handling your tap.
- Processing time: your event handlers (JavaScript) run.
- Presentation delay: the browser recalculates layout and paints the update.
Most poor INP comes from too much JavaScript running on the main thread.
| Common cause | Typical example |
|---|---|
| Heavy third-party scripts | Chat widgets, A/B testing tools, tag managers, ad scripts |
| Large JavaScript bundles | Whole libraries loaded for small features |
| Long tasks during load | Hydration of a big page while the user tries to tap |
| Expensive event handlers | Filtering hundreds of products on every keystroke |
| Huge DOM | Thousands of elements making layout slow |
| Layout thrashing | Code 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
| Platform | Quick wins |
|---|---|
| Shopify | Remove unused apps (their scripts often stay), audit theme JavaScript, limit live chat and pop-up apps |
| WordPress | Reduce plugins, disable scripts on pages that don't need them, avoid heavy page builders for key pages |
| Wix / Squarespace | Limit third-party embeds and apps; keep pages simpler |
| Custom React / Next.js | Server 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
- Check INP in Search Console and PageSpeed Insights (field data).
- Record slow interactions in Chrome DevTools on a mid-range phone or with CPU throttling.
- Remove or delay unnecessary third-party scripts.
- Break up long tasks and respond visually first.
- Debounce search and filters.
- Cut unused JavaScript and lazy-load features.
- Simplify large DOMs and long lists.
- 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.




