SEO

INP

Also called Interaction to Next Paint

A Core Web Vital measuring how long a page takes to paint a visible response after a tap, click or key press.

Quick facts: INP

Category
SEO
Also called
Interaction to Next Paint
Level
Intermediate
Affects
Perceived responsiveness, form completion, page experience signals
Where to see it
Search Console Core Web Vitals report, PageSpeed Insights field data, Chrome performance panel
In this article4
  1. What INP measures
  2. Why INP matters
  3. Where INP goes wrong
  4. How to act on it

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.

Do and do not

Do

  • Find the slow interaction before changing any code
  • Break long tasks so the browser can paint between them
  • Test with processor throttling on a simulated phone

Do not

  • Treat it as a loading metric and compress images
  • Add third-party tags without auditing the total
  • Judge responsiveness from your own desktop machine

Questions people ask about this

How is INP different from the old FID metric?

First Input Delay measured only the wait before the browser could begin handling a visitor's very first interaction, and stopped counting there. INP looks at interactions throughout the whole visit, and measures right through to the moment the screen visibly updates. That means it includes your own code's running time and the paint, which is where most real sluggishness lives.

Will compressing my images improve INP?

Almost certainly not. Image weight affects how quickly a page appears, which is a different metric. INP is about what happens when someone taps or clicks: how much JavaScript has to run, how busy the main thread already is, and how long the browser takes to paint the result. Look at scripts and third-party tags instead.

Why does my site feel fast to me but score badly?

Because you are probably testing on a fast computer with a good connection, and your visitors are not. Interaction delays scale with processor speed, so work that finishes imperceptibly on a laptop can take a visible pause on a mid-range phone. Test with processor throttling enabled, and trust the field data gathered from real devices over your own impression.

Related terms

Found this useful?

Share it, or ask an AI to summarise it

Back to the glossary

Knowing the term is the easy part

Applying it to your own site and budget is the work. Book a call and I will tell you what actually applies to you.