Interaction to Next Paint (INP): Causes and Fixes
- Filed November 10, 2026
- Page speed and Core Web Vitals, guide 5 of 10
Interaction to Next Paint measures how quickly a page responds visually when a user clicks, taps or types. It replaced First Input Delay as a Core Web Vital in March 2024; web.dev’s FID page now states that FID “is no longer a Core Web Vital, and has been replaced by the Interaction to Next Paint (INP) metric” (web.dev on FID). Google’s guidance is that pages should have an INP of 200 milliseconds or less at the 75th percentile of page loads (web.dev on Web Vitals). Fixing INP means finding the slow interactions real users experience and then shortening the part of each interaction that takes longest.
How INP is measured
INP observes “the latency of all interactions a user has made with the page”, and the final value is “the longest interaction observed, ignoring outliers”; web.dev explains that one highest interaction is ignored for every 50 interactions (web.dev on INP). Hovering, zooming and scrolling are not counted as interactions.
Each interaction has three phases:
| Phase | What happens | Possible cause of delay |
|---|---|---|
| Input delay | Time from the input until event handlers start | The main thread is busy with other work |
| Processing duration | Running all event handler callbacks for the interaction | Heavy handler code |
| Presentation delay | From handlers finishing until the next frame is painted | Large rendering work, layout, big DOM |
FID measured only the input delay of the first interaction. INP covers the whole latency of every interaction, which is why a page that passed FID can fail INP.
Why lab tests struggle with INP
INP depends on what users do. web.dev notes that a lab INP value depends on which interactions are performed during the test and that some lab tools do not report INP at all. Total Blocking Time (TBT) can serve as a lab proxy, but web.dev says it is “not a substitute for INP in and of itself”.
So start with field data:
- Search Console’s Core Web Vitals report and PageSpeed Insights show CrUX INP at the 75th percentile.
- Real-user monitoring with the attribution build of the web-vitals JavaScript library reports which interaction was slow and which phase dominated. web.dev’s guide to finding slow interactions in the field describes this approach, including use of the Long Animation Frames API (finding slow interactions in the field).
An interaction-latency troubleshooting workflow
- Confirm the problem in field data for a template and device type, reading mobile and desktop separately.
- Find the slow interactions. Use attribution data to list the interaction targets (a “Filter” button, a menu toggle, an “Add to cart” button) and their phase breakdown.
- Reproduce in the lab. In Chrome DevTools, record a performance trace while performing the slow interaction on a throttled CPU.
- Read the dominant phase:
- Long input delay: something else is occupying the main thread at the moment of input (a long task from a third-party script, hydration, timers).
- Long processing: the handler itself does too much.
- Long presentation delay: the update triggers expensive rendering.
5. Fix that phase (below).
- Verify in the lab, then wait for field data to update.
Fixes by phase
Input delay
- Break up long tasks. web.dev defines a long task as “any task that takes longer than 50 milliseconds” and explains that such tasks can cause poor INP (optimizing long tasks).
- Defer or remove third-party scripts that run during page use, including tags loaded through a tag manager.
- Ship less of your own JavaScript: bundle size and code splitting reduce the parsing and execution work that competes with input.
- Avoid heavy work in timers and intervals that coincide with likely interactions.
Processing duration
- Do the minimum work needed to show visual feedback, then yield. web.dev’s INP optimization guide recommends yielding to the main thread often, and gives a pattern using
requestAnimationFramefollowed bysetTimeoutto keep non-critical work from blocking the next frame (optimizing INP). - Debounce input handlers that fire on every keystroke.
- Move expensive computation off the main thread (web workers) where possible.
Presentation delay
- Keep the DOM size reasonable; web.dev notes that rendering work tends to scale with DOM size.
- Avoid layout thrashing (forced synchronous layout) by batching reads and writes.
- Use
content-visibilityto skip rendering of off-screen content. - Avoid animating properties that trigger layout; transforms and opacity are cheaper.
Before and after (illustrative)
Before: a product filter that recalculates and re-renders the entire grid synchronously on click.
filterButton.addEventListener('click', () => {
const results = filterProducts(allProducts, getFilters()); // heavy
renderGrid(results); // heavy
});
After: show immediate visible feedback, then yield before the heavy work.
.is-loading { opacity: 0.6; cursor: progress; }
filterButton.addEventListener('click', () => {
const label = filterButton.textContent;
filterButton.classList.add('is-loading'); // visible change the next frame can paint
filterButton.textContent = 'Filtering...'; // visible text change
filterButton.setAttribute('aria-busy', 'true'); // tells assistive technology; draws nothing by itself
requestAnimationFrame(() => {
setTimeout(() => {
const results = filterProducts(allProducts, getFilters());
renderGrid(results);
filterButton.classList.remove('is-loading');
filterButton.textContent = label;
filterButton.removeAttribute('aria-busy');
}, 0);
});
});
aria-busy alone produces no visible change; the class and text change are what the user sees in the next paint.
- Expected result: the next frame paints right after the click with the visible loading state; the heavy work runs afterward, so the interaction’s measured latency falls.
- Confirm: check that a DevTools trace shows the interaction’s presentation before the long task, then watch field INP for the template over the following weeks.
- Still open: if
filterProductstakes seconds, users still wait for results; the code itself may need optimizing or moving to a worker. Yielding fixes responsiveness, not total work.
INP and search
Core Web Vitals, including INP, are used by Google’s ranking systems, but Google’s page experience documentation says good scores do not guarantee top rankings (Google on page experience). INP matters most to users trying to use a page: buttons that seem broken, menus that lag, forms that freeze.
INP checklist
- [ ] Field INP checked by template and device.
- [ ] Slow interactions identified with attribution data.
- [ ] Dominant phase measured in a lab trace.
- [ ] Long tasks during interaction broken up or deferred.
- [ ] Handlers give visual feedback first and yield.
- [ ] Rendering cost of the update reduced.
- [ ] Field data rechecked after it has had time to update.