Skip to the indexed answers
Digital Marketing Index

usdigitalmarketingindex.com SEO

Which bottlenecks most often create high Interaction to Next Paint on interactive webpages?

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.

  1. 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.
  2. List the interactions on the affected template: menu toggle, search field, filters, accordion, add to cart, consent dialog buttons.
  3. Reproduce each in a browser’s performance panel, with CPU throttling to approximate a mid-range phone, and record.
  4. 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.

  1. Re-record the interaction with the same throttling, and compare each phase.
  2. Check that the fix did not move the delay to a different interaction.
  3. 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.

Link trail

Reader comments on this answer

Add your comment to this answer

Your email address will not be published. Required fields are marked *