What INP measures
Interaction to Next Paint measures responsiveness. Every time a visitor clicks, taps or presses a key, the browser times how long it takes before the screen shows something changed. Not when the code started running — when the visitor could actually see a result. The page’s INP is drawn from the slowest of those interactions across the whole visit, setting aside rare outliers on pages with a great many of them.
It counts clicks, taps and key presses only. Scrolling and hovering are excluded, because they are handled differently by the browser and do not reflect the same kind of delay.
Each interaction breaks into three stretches: the wait before the browser can start on your event handler because it is busy with something else, the time your handler itself takes to run, and the time after that before the browser can paint the updated screen. Fixes differ by stretch, so the useful diagnostic is finding which one dominates. INP replaced First Input Delay as a Core Web Vital in March 2024.
Why INP matters
It captures the frustration people actually describe. Nobody says a page had a poor paint metric; they say the menu did not open, the form field lagged behind their typing, or they pressed the button twice because nothing happened. INP is the metric that finally puts a number on that.
It is also independent of loading speed. A page can render beautifully and quickly and still be unpleasant, because the weight has moved into scripts that run whenever someone touches the interface. That is common on sites carrying a chat widget, a tag manager full of tags, several ad pixels and a consent banner, all competing for the same single thread as the visitor’s click.
The device matters as much as the code. On a mid-range Android phone — which is what most visitors in Nepal are holding — work that a laptop absorbs without noticing takes long enough to feel like a stall.
Where INP goes wrong
The most common misdiagnosis is treating it as a loading problem and compressing images. Images have almost nothing to do with it. The causes are scripts running too long, too much work packed into a single click handler, and a page structure so large that painting the change is slow even after the code has finished.
Third-party tags are the usual culprit, and the hardest to argue about internally, because each one was added for a reason and nobody owns the total. The second mistake is testing on a fast desktop machine with no throttling, where every interaction feels instant. The third is relying on lab tools alone: most of them do not interact with the page at all, so they cannot report this metric properly.
How to act on it
Start with real data. Search Console shows which page groups are struggling, and a field measurement script in the browser can identify the specific interaction and element responsible. Guessing wastes weeks here.
Then reduce the work. Break long tasks into smaller pieces so the browser can paint between them, move anything that is not urgent out of the click handler, and give the visitor immediate visual feedback — a pressed state, a spinner — before the slower work completes. Audit every third-party tag and remove or delay the ones nobody can justify. Shrink oversized pages, since a heavy structure slows the paint itself. Improvements show up in reports only as new visits accumulate, so change one thing, wait, then look. This is page speed work aimed at the interface rather than the download, and it sits with the other Core Web Vitals rather than replacing them.
