Quick Answer
Improve Interaction to Next Paint by finding the particular click, tap or keystroke that responds slowly, then reduce its input delay, event-handler work and rendering delay. Use field data to confirm the problem, real-user monitoring to identify the interaction, and Chrome DevTools to trace the work. A good INP is 200 milliseconds or less at the 75th percentile of visits, assessed separately for mobile and desktop.
Interaction to Next Paint, or INP, describes how quickly a page gives visual feedback after a visitor interacts with it. It is not a loading-speed score. A page can appear quickly and still feel unresponsive when a menu, filter, form or editor takes too long to react.
The useful way to improve INP is to work from evidence. Start with the affected device group and URL pattern, identify the slow interaction, inspect its timing, make one targeted change and retest the same action. That sequence prevents a broad performance clean-up from hiding whether the interaction actually improved.
What Does INP Measure?
INP measures the time from a qualifying interaction until the browser presents the next frame. Clicks, taps and keyboard input qualify. Hovering, scrolling and zooming do not, although code triggered by those actions can still block a later click or keypress.
For a short visit, the reported value is usually the slowest interaction. On longer visits, the algorithm ignores one of the highest-latency interactions for every 50 interactions. This reduces the effect of an isolated outlier without turning INP into an average. A visit with no qualifying interaction has no INP value.
Google classifies INP as good at 200 milliseconds or less, needing improvement above 200 and up to 500 milliseconds, and poor above 500 milliseconds. The site-level assessment uses the 75th percentile of visits and considers mobile and desktop separately. That percentile is across visits; it should not be confused with the interaction selected within an individual visit.
The Three Parts of an Interaction
1. Input delay
Time from the user action until its event callbacks begin. Long tasks already occupying the main thread commonly cause this delay.
2. Processing
Time spent running the event callbacks. Heavy synchronous work inside a handler makes this phase longer.
3. Presentation delay
Time from the callbacks finishing until the browser presents the next frame. Layout, style and painting work sit here.
Confirm the Problem With Field Data
Start With Search Console or PageSpeed Insights
The Core Web Vitals report in Search Console groups URLs that appear to have similar behaviour. It is useful for finding affected templates and for separating mobile from desktop problems. PageSpeed Insights can show Chrome UX Report data for an individual URL and, where URL data is unavailable, may show origin-level data. Check which scope is displayed before treating it as evidence for one page.
Field data answers the first question: do real visitors experience a slow response? It usually cannot identify the exact control or JavaScript function responsible. It also reflects a rolling collection period, so it changes more slowly than a lab trace.
Capture the Interaction in Real-User Monitoring
Real-user monitoring can record interaction latency on your own pages. The web-vitals library and its attribution build can add details such as the interaction target, event type and timing phases. Collect only the data you need, apply your privacy and consent requirements, and avoid sending user-entered values.
Add useful context such as page template, viewport class and whether the interaction occurred during initial loading or later in the visit. Compare repeated cases rather than relying on one trace. An interaction inside a cross-origin iframe can contribute to Chrome UX Report INP but may be invisible to JavaScript running in the top-level page, which is a material limitation when advertisements or embedded tools are involved.
Reproduce the Same Action in Chrome DevTools
Open the Performance panel in Chrome DevTools, record the page and perform the affected action. Inspect the interaction and its main-thread activity. Test both during startup and after the page has settled; an interaction may be slow only while scripts are initialising.
CPU and network throttling can make delays easier to see, but it is an approximation rather than a copy of every visitor’s device. Calibrate the test against field observations where possible. Total Blocking Time from Lighthouse can reveal excessive main-thread work during loading, but it is only a proxy for INP because an automated run may not perform the troublesome interaction.
Reduce Input Delay
Input delay is the wait before the browser can start the interaction’s event callbacks. It grows when a long task, often startup JavaScript or third-party code, already occupies the main thread.
- Ship less JavaScript on the initial route. Remove unused code, split bundles by route or feature, and load non-essential modules when they are needed.
- Review third-party tags by purpose and timing. Delay optional widgets until consent, intent or idle time where the user experience allows it.
- Break long tasks into smaller pieces so the browser can handle input between them.
scheduler.yield()preserves task ordering in supporting browsers; asetTimeout()fallback can provide a similar opportunity to yield. - Move compatible computation to a Web Worker when it does not require direct DOM access. Moving a script to a worker is not automatically safe; test functionality, consent behaviour and performance.
- Avoid starting large background jobs immediately after the page looks ready. An early click can still collide with work that continues after the first paint.
Do not treat requestIdleCallback() as a direct replacement for yielding during an active interaction. It schedules work for an idle period and has different timing guarantees.
Shorten Event-Handler Processing

The processing phase covers the callbacks attached to the interaction. Keep synchronous handler work small enough to provide a visible response quickly.
- Perform only the work needed for immediate feedback in the first handler. Defer analytics, non-essential calculations and secondary interface updates.
- Avoid parsing large datasets, sorting long lists or serialising large objects on the main thread in response to a click.
- Debounce or coalesce repeated work where the interface does not need to process every intermediate input, while preserving keyboard and assistive-technology behaviour.
- Remove duplicate listeners and confirm that framework state changes do not cause unrelated components to re-render.
- Measure before memoising or adding complexity. An optimisation that saves little work can make the code harder to maintain without improving INP.
When an operation genuinely takes time, update the interface first with a pressed state, spinner, status message or disabled control where appropriate, then yield before continuing. Immediate feedback reduces uncertainty, although the full interaction must still complete promptly.
Cut Presentation Delay
Presentation delay begins after event callbacks finish and ends when the browser presents the next frame. Large style recalculations, layout and painting work can dominate this phase.
- Avoid forced synchronous layout. Do not repeatedly read layout values such as
offsetWidthimmediately after writing styles inside a loop. - Batch DOM reads separately from DOM writes so the browser can calculate layout once.
- Reduce unnecessary DOM depth and the number of elements affected by a state change. A large DOM is not automatically slow, but it increases the potential scope of style and layout work.
- Use
content-visibility: autofor suitable off-screen sections, then test keyboard navigation, in-page search and layout stability. - Update only the part of the page that changed. Rebuilding a whole list, table or application shell after a small interaction can create avoidable work.
- Prefer simple visual changes for immediate feedback. Expensive filters, shadows or broad animations can delay the frame on weaker devices.
Use the Performance panel’s rendering and layout information to confirm the cause. Do not assume that JavaScript execution is the only problem when the trace shows most time in style, layout or paint.
Retest the Interaction and Watch Field Results
Repeat the same action under the same lab conditions after each material change. Confirm that the total interaction duration fell and that the work did not merely move from one phase to another. Test keyboard input as well as pointer input where both are supported.
Next, release the change carefully and monitor your real-user data. Break the results down by template and device class, and watch error reporting alongside performance. A change that improves a trace but breaks a menu, form validation or analytics is not a successful fix.
Search Console and public Chrome UX Report figures take time to reflect new visits. Your own monitoring can provide an earlier signal, while the public 75th-percentile result remains the final field check.
A Practical INP Fixing Order
- Confirm scope: identify the affected device group, template and traffic segment in field data.
- Identify the action: use attribution from real-user monitoring, support reports or careful reproduction.
- Trace the three phases: record the interaction in DevTools and find whether input delay, processing or presentation dominates.
- Apply one matching fix: reduce competing long tasks, handler work or rendering work.
- Test functionality: check mouse, touch, keyboard and relevant assistive-technology flows.
- Verify in the field: monitor the deployed change and allow public datasets time to refresh.
This approach also fits a wider website performance optimisation programme. Keep INP work separate from loading metrics when diagnosing, then check that the completed change has not harmed Largest Contentful Paint or layout stability.
Frequently Asked Questions
Why can INP be poor when Lighthouse looks good?
INP is primarily a field metric based on real visits. A Lighthouse run may not perform the menu, form or other interaction that is slow for users. Use Lighthouse Total Blocking Time as a diagnostic clue, then reproduce the affected interaction and confirm the result with field data.
Does scrolling count towards INP?
No. INP measures click, tap and keyboard interactions. Scrolling, hovering and zooming are not counted as INP interactions, although work attached to them can still occupy the main thread and delay a later qualifying interaction.
Can a caching plugin or CDN fix poor INP?
Caching and a CDN can shorten loading and reduce work competing during startup, but they do not automatically fix expensive event handlers, forced layout or a large DOM. Diagnose the slow interaction before deciding whether cache, script or rendering changes are required.
How long does an INP improvement take to appear in Search Console?
Search Console groups URLs using Chrome UX Report field data collected over a rolling period, so a deployed fix will not appear immediately. Verify the new behaviour in the lab and in your own real-user data while the public field dataset accumulates newer visits.
Sources and image credits
Body diagrams from Google’s Optimize Interaction to Next Paint, licensed under CC BY 4.0. These explain browser behaviour and are not measurements from my website.
- web.dev: Interaction to Next Paint
- web.dev: Optimise Interaction to Next Paint
- web.dev: Find slow interactions in the field
- web.dev: Diagnose slow interactions in the lab
- web.dev: Optimise long tasks
- web.dev: Avoid large layouts and layout thrashing
- Chrome DevTools: Performance panel overview
- Google Search Console: Core Web Vitals report
- W3C: Event Timing specification
Featured illustration: conceptual artwork prepared for StuartKerrs.com.

Leave a Reply