How to Fix a Slow Interaction to Next Paint Score
A client rang me in October because the booking form on her site felt broken on phones. Nothing was broken. The form submitted, the confirmation appeared, the booking landed in her inbox.

A client rang me in October because the booking form on her site felt broken on phones. Nothing was broken. The form submitted, the confirmation appeared, the booking landed in her inbox. The problem was that tapping Submit produced no visible change for about seven tenths of a second, which is long enough that most people tap again. Her PageSpeed report showed a green Largest Contentful Paint, a green layout shift score, and a red Interaction to Next Paint of 612 ms.
Interaction to Next Paint took over from First Input Delay as a Core Web Vital in March 2024, and it catches a kind of slowness the old metric missed entirely. First Input Delay only measured how long the browser took to start handling the first tap. Interaction to Next Paint measures the whole round trip: the tap, the work your scripts do in response, and the moment the screen actually changes. Plenty of sites that passed the old metric comfortably now fail the new one, and the familiar advice about compressing images and adding caching does nothing at all for it.
What the number actually measures
The metric watches every click, tap and key press during a visit, measures how long each one takes to produce a painted update, and reports close to the worst result. On a page with only a handful of interactions it is simply the slowest one. Under 200 ms counts as good, 200 to 500 ms needs work, and past 500 ms is poor. The figure in Search Console is the 75th percentile of real visits over a rolling 28 days, so one unlucky tap on your own laptop proves nothing either way.
Each measurement has three parts, and knowing which part dominates saves you days of guessing. Input delay is time the browser spends waiting because the main thread is busy with something else. Processing time is your own event handler doing its job. Presentation delay is the gap between the handler finishing and the browser drawing the next frame. Small sites usually fail on the first and third parts, not the second, which is why rewriting your own code is rarely the right opening move.
That booking form is a good illustration. Her handler ran in 31 ms. The input delay was 448 ms, because a chat widget was deserialising its message history at the exact moment people reach the bottom of the page.
Finding the interaction that fails
Field data tells you the score. It will not tell you which button is at fault. You need both, in this order.
- Start with Search Console. Open the Core Web Vitals report, mobile, and look at the URL groups flagged for the metric. If one template is listed, the problem is in that template, not across the site.
- Install the Web Vitals extension in Chrome and turn on the console logging option. Load the page on a throttled connection, then click things. Each interaction prints its target element and the three part breakdown. This is the single fastest way to find the guilty control.
- Throttle the processor, not just the network. In DevTools, under Performance, set CPU to a four times or six times slowdown. A mid range Android phone from 2022 is roughly four times slower than a modern laptop. Without this step most problems simply do not reproduce.
- Record a performance trace while you click. Look for long tasks, the grey blocks with a red corner, anything over 50 ms. Hover one and the call stack names the script that owns it.
- Check the same page with scripts blocked. DevTools lets you block a request URL pattern. Block the analytics or chat domain, reload, click again, and compare. This turns an argument about whether a widget matters into a number.
On the booking site this whole sequence took about forty minutes, and step five settled it. With the chat widget blocked, the interaction dropped to 94 ms.
Minifying your JavaScript will not fix this
Almost every performance plugin offers to minify and combine your JavaScript, and almost every article about slow interactions mentions it in the first paragraph. For this particular metric it is close to useless, and combining files can make matters worse.
Minification removes whitespace and shortens variable names. It reduces download size. It does not reduce the amount of work the processor has to do once the file arrives, and interaction delay is a processor problem, not a bandwidth problem. A 40 KB script that spends 300 ms parsing JSON still spends 300 ms parsing JSON after you strip its comments.
Combining is worse. Five small scripts that the browser can parse in separate chunks become one long task that blocks the main thread in a single unbroken stretch, and a tap arriving during that stretch waits for all of it. I have watched a site go from 280 ms to 410 ms after switching on a combine option, with no other change.
What does help is doing less work, later, in smaller pieces. Remove the widget nobody uses. Load the share buttons only after the first interaction. Break one long loop into chunks and hand control back to the browser between them. The honest version of this advice is unglamorous: the fix is usually deletion.
The fixes that move the number
Third party scripts are the first place to look, because they run on the main thread with the same priority as your own code and you did not write them. A typical small business site I audit carries analytics, a tag manager, a chat widget, a cookie banner, a review badge and a font service. The chat widget is almost always the heaviest, often 180 to 400 KB of script that initialises on load. Loading it on a click of a small static button, rather than on page load, is a five minute change that regularly takes 200 ms off the score.
Cookie banners deserve a special mention. Several popular ones scan the entire document on load to find and rewrite script tags, which produces one enormous task at exactly the moment visitors try to dismiss the banner. The dismiss button is then measured as your slowest interaction. If your flagged interaction is the consent button, the banner is the problem, not your site.
After that, look at your own handlers for three habits. Reading a layout property such as offsetHeight immediately after changing a style forces the browser to recalculate layout mid handler. Attaching a listener to every item in a long list instead of one listener on the container multiplies the setup cost. Doing non urgent work inside the handler, such as sending an event to analytics, delays the paint; move it after the visual update instead.
Presentation delay has its own cure. If the handler updates a large section of the page, the browser has to lay out and paint all of it before the frame appears. Narrowing what changes helps, and so does giving the browser a cheap immediate acknowledgement: a pressed state on the button, a spinner, a disabled attribute. The work still takes as long, but the next paint happens quickly, which is literally what the metric counts.
One more thing worth checking is images and media inserted during the interaction. If a tap opens a gallery, images without declared dimensions will push the layout about, and the related guidance on fixing cumulative layout shift applies to the frame the metric is waiting for. The same goes for deferred loading of anything above the fold, covered in the notes on lazy loading images properly.
What to do this week
Pick your busiest template, open it on a phone that is at least two years old, and tap the three controls real visitors use most: the menu, the search box, the main button. Count out loud. Anything you can perceive as a wait is over 200 ms and belongs on a list.
Then open the page with the chat widget and the cookie banner blocked and tap the same three things. If the difference is obvious, you have your answer and you have not written a line of code. More of the measurement side is collected in the performance section, though the diagnosis above covers most small sites. The cases I cannot solve this way are usually single page applications with heavy client side routing, and those need a different conversation.
FAQ
What is a good Interaction to Next Paint score?
Under 200 ms at the 75th percentile of real visits. Between 200 and 500 ms needs work, and over 500 ms is treated as poor.
Why did my score get worse without any changes?
Usually a third party script updated itself, or your visitor mix shifted towards slower phones. Both change the field data while your code stays the same.
Does this metric affect search rankings?
It is part of the page experience signals, so it carries a little weight, nothing like relevance. The stronger argument is that people tap twice and submit duplicate forms.
Can a static site fail this metric?
Yes. A plain HTML site with a chat widget and a consent banner can fail it, because the slow work belongs to those scripts rather than to your pages.
More in Performance
Performance
How to Load Web Fonts Faster on a Small Website
A small business site I looked at last month scored 94 on PageSpeed for desktop and 61 on mobile.
Performance
How to Reduce Server Response Time on a Small Website
You compressed every image, removed the slider and switched to a lighter theme, yet your speed report still shows a red warning...
Performance
How to Set Up Browser Caching on a Small Website
Your PageSpeed report keeps flagging "Serve static assets with an efficient cache policy", and every returning visitor...