usdigitalmarketingindex.com SEO
Which bottlenecks most often create high Interaction to Next Paint on interactive webpages?
Updated November 15, 2026
Three, one for each phase of an interaction: the main thread is busy when the user acts, the event handlers do too much work, or the browser has too much to render before it can paint the result. web.dev describes the life of an interaction in those terms: an input delay until event handlers start running, the handlers themselves, and then a delay before the next frame is presented (web.dev’s explanation of INP). Which of the three dominates on a given page has to be read from a trace. No published ranking says which is the usual culprit across the web, so the practical answer is a method for finding out, with the known causes of each phase.
Interaction selection
INP is “a metric that assesses a page’s overall responsiveness to user interactions by observing the latency of all click, tap, and keyboard interactions”. The reported value is “the longest interaction observed, ignoring outliers”. The thresholds on the same page: 200 milliseconds or less is good, above 500 milliseconds is poor.
So the task is to find the slow interactions.
- Field data first. Real-user monitoring that records INP with attribution reports which element was interacted with and how the time divided. Without it, the Core Web Vitals report in Search Console tells you which URL groups have a problem, not which interaction.
- List the interactions on the affected template: menu toggle, search field, filters, accordion, add to cart, consent dialog buttons.
- Reproduce each in a browser’s performance panel, with CPU throttling to approximate a mid-range phone, and record.
- Rank them by duration.
Test early interactions too. A tap made while the page is still loading scripts meets a busy main thread.
Choose the interactions from field data where it exists. A lab run and field data can disagree, for reasons set out in the guide to why field Core Web Vitals measurements can disagree with lab testing results.
Main-thread and event handler work
A trace of one interaction, opening a filter panel. The durations are example values for illustration, not measurements from a real site.
| Phase | Duration (example) | What was happening |
|---|---|---|
| Input delay | 180 ms | A third-party script was executing a long task when the tap arrived |
| Processing duration | 240 ms | The click handler recalculated all filter counts and updated application state |
| Presentation delay | 90 ms | The browser recalculated style and layout for a large list before painting |
| Total | 510 ms | Poor: above 500 ms |
Each phase has its own causes.
Input delay. The handler cannot start because the main thread is occupied.
- Long tasks from script evaluation during load
- Third-party scripts: tags, analytics, chat, advertising
- Timers and intervals firing repeatedly
- Other interactions queued ahead
Processing duration. The handlers take too long.
- Heavy computation inside the handler
- Several handlers attached to the same event, including third-party listeners
- Synchronous state updates that re-render a large part of an application
- Reading layout properties and writing styles in alternation, forcing repeated layout
Long tasks and rendering delay
Presentation delay. The handlers have finished and the frame is not ready.
- A very large DOM, so style and layout recalculation is slow
- Rendering a large amount of new markup in one go
- Layout thrashing triggered by the update
- Expensive paint, such as large shadows or filters over a wide area
The connection between long tasks and input delay is direct. The browser runs one task at a time on the main thread. A task that takes 300 ms makes any tap arriving during it wait for the remainder. Breaking long tasks into shorter ones gives the browser gaps in which to respond.
Remediation priorities
Fix the phase that holds the most time, for the interactions that are slowest in the field.
| Dominant phase | Remedies |
|---|---|
| Input delay | Defer or remove scripts that run long tasks; break up initialization work; load third-party code after the page is interactive, or on demand |
| Processing duration | Do the minimum needed to update the screen, and defer the rest; yield to the main thread inside long handlers; debounce input handlers; remove duplicate listeners |
| Presentation delay | Reduce DOM size; render long lists in portions; avoid forced layout; use CSS containment where it applies |
For the example trace, processing is the largest phase at 240 ms, and input delay is close behind at 180 ms. A reasonable first step is to make the click handler show the panel at once and compute filter counts afterward, then to defer the third-party script. Either change alone would bring the example total under 500 ms. Both would be needed to approach 200 ms.
A general principle helps in every phase: give visual feedback first. Paint the opened panel, the pressed state, or a progress indicator in the next frame, and do the remaining work after that paint.
Verify in the same way the problem was found.
- Re-record the interaction with the same throttling, and compare each phase.
- Check that the fix did not move the delay to a different interaction.
- Watch field INP for the template over the following weeks.
State results with their type. A trace is one interaction on one machine. Google’s assessment uses field data, with the target of “an INP of less than 200 milliseconds” (Google’s documentation on Core Web Vitals).
Two cautions. Do not optimize an interaction nobody performs. And do not judge by a fast development machine, where a handler that takes 240 ms on a phone runs in a fraction of that.
Third-party scripts are named above as a source of input delay. A live chat widget is a specific case, with its own loading options, examined in the guide to how a third-party chat widget can increase page interaction latency.
The method: find the slow interaction in field data, record it, read the three phases, and fix the longest.
Add your comment to this answer