Interaction to Next Paint replaced First Input Delay as a Core Web Vital in March 2024, and it’s a much tougher metric. FID only measured the delay before the browser started handling the first interaction. INP measures the full time from a tap or click until the screen visibly updates, and it looks at nearly every interaction during the visit, not just the first.
The result is that many WordPress sites that passed FID comfortably now fail INP. The good-threshold is 200 milliseconds. Above 500 milliseconds is considered poor. Those numbers sound generous until you realise how much JavaScript a typical WordPress page runs.
What INP actually measures
Every time a user clicks, taps or presses a key, the browser goes through three phases:
- Input delay. The time before the browser can start handling the event, because it’s busy with something else.
- Processing time. The time spent running event handlers, the JavaScript attached to that click or keypress.
- Presentation delay. The time to recalculate styles, lay out the page and paint the updated screen.
INP is roughly the slowest interaction during a page visit, with a little allowance for outliers on pages with many interactions. If one click on a mobile menu takes 600 milliseconds, that becomes the page’s INP for that visit, even if everything else was fast.
Why WordPress sites struggle with INP
The common thread is JavaScript on the main thread. The browser has one main thread for running JavaScript, handling input and rendering. While a script runs, nothing else can happen. If a 300-millisecond task is running when someone taps a button, they wait at least 300 milliseconds.
Typical sources on WordPress sites:
- Page builders that load large front-end frameworks for animations, sliders and interactive widgets.
- Third-party scripts: analytics, tag managers, chat widgets, heatmaps, ad scripts and social embeds.
- Theme JavaScript for mega menus, sticky headers and scroll effects.
- jQuery and plugins built on it, often loaded for small features.
- WooCommerce scripts, especially cart fragments and variation selectors on product pages.
- Cookie consent banners that run heavy logic when users click accept or reject.
Each one might be fine alone. Together, they keep the main thread busy and make every interaction wait.
Finding your slow interactions
Field data first
Start with real-user data. PageSpeed Insights shows INP from Chrome users at the top of the report if your site has enough traffic. Search Console’s Core Web Vitals report groups URLs by INP status.
Field data tells you whether you have a problem and on which page types. It doesn’t tell you which interaction is slow.
Find the interaction
Think about what people actually do on the failing pages. On a typical business site, the candidates are:
- Opening the mobile menu
- Clicking accept or reject on the cookie banner
- Opening an accordion or tab
- Typing in a search box or form field
- Choosing a product variation or adding to cart
The Web Vitals Chrome extension can log INP for each interaction as you use the page. Turn on its console logging, interact with the page on a throttled CPU, and it reports which element and which interaction was slow.
Profile in DevTools
In Chrome DevTools, open the Performance panel and set CPU throttling to 4x or 6x slowdown to mimic a mid-range phone. Start recording, perform the interaction, then stop.
The Interactions track shows each interaction with its duration. Expand it and you’ll see the input delay, processing and presentation phases. The main thread track below shows exactly which scripts ran. Long tasks are marked with red corners.
That tells you whether the problem is something else blocking the thread (input delay), the click handler itself (processing) or rendering work (presentation).
Fixing input delay
High input delay means the main thread was busy when the user interacted. The fix is to reduce or break up the work happening during page load and after.
- Remove scripts you don’t need. Audit every third-party script. Is the heatmap tool still in use? Is the chat widget generating leads? Each removal frees the main thread.
- Delay non-essential scripts. Many optimisation plugins can delay scripts until the first user interaction. That helps LCP, but be careful: delayed scripts all run at once when the user first interacts, which can make that first interaction slow. Some tools load delayed scripts after a short idle period instead, which is often better for INP.
- Load chat widgets on demand. Show a lightweight button and only load the full widget when someone clicks it.
- Avoid large hydration work. Some themes and builders initialise every widget on the page at load. Lazy-initialising widgets below the fold spreads the work out.
Fixing processing time
Slow processing means the event handler itself does too much. This is more common with custom code and some plugins.
- Do less on each interaction. If a click handler recalculates the whole page or makes several DOM queries, simplify it.
- Yield to the browser. For handlers that must do a lot, update the visible part first and defer the rest. The newer scheduler.yield() API, or a setTimeout with zero delay as a fallback, lets the browser paint before continuing.
- Move analytics calls out of the critical path. Tracking code attached to clicks often runs before the visible response. Push it after the paint, as above.
- Debounce input handlers. Search-as-you-type features that run a query on every keystroke should wait until the user pauses.
Fixing presentation delay
Presentation delay comes from rendering work after the handler finishes.
- Large DOM size. Pages with thousands of elements take longer to recalculate styles and layout. Page builders and mega menus are common culprits. Simplifying layouts and removing hidden duplicate content, such as separate mobile and desktop menus, both help.
- Expensive CSS. Complex selectors, heavy shadows and filters on many elements slow rendering.
- Layout thrashing. JavaScript that alternates between reading layout values and changing styles forces repeated recalculation. Batch reads and writes.
Reducing DOM size is one of the most effective INP improvements on builder-heavy sites. Lighthouse reports DOM size; under 1,500 elements is a reasonable target for most pages.
WordPress-specific fixes worth trying
- Replace jQuery-dependent features with lighter alternatives or native browser features. The details element makes accordions with no JavaScript at all.
- Use the Interactivity API for new interactive blocks. It’s designed to be lightweight and to work with server-rendered markup.
- Check the cookie banner. Some consent tools run a lot of code when users click accept, such as loading every blocked script at once. Choose a lightweight tool or configure it to load scripts gradually.
- On WooCommerce product pages, test the variation dropdowns and add-to-cart button under CPU throttling. Swatch plugins and dynamic pricing plugins can add heavy handlers.
- Remove unused builder widgets and modules. Many builders let you disable modules site-wide, so their scripts aren’t loaded.
Measure, change one thing, measure again
INP improvements are easy to misjudge, because interactions are variable. Change one thing at a time, retest the same interaction under the same throttling, and compare. Then watch field data over the following weeks to confirm real users benefit.
A site that drops from 450 milliseconds to 180 doesn’t just pass a metric. It feels noticeably more responsive to use, especially on the mid-range phones most of your visitors are probably holding.
Why mobile INP is usually worse
Field data for INP is almost always worse on mobile than on desktop. Phones have slower processors, so the same JavaScript takes three to five times longer to run. Touch interactions also tend to trigger more work, such as menus that animate open and overlays that lock scrolling. When you test, always use CPU throttling, and if you can, test on a real mid-range Android phone connected to DevTools through remote debugging. It’s the most honest picture of what most visitors experience, and it often reveals slow interactions that never show up on a developer’s laptop. Interaction to next paint rewards that kind of steady, measured work more than any single plugin setting.
Frequently asked questions
My site passes in Lighthouse but fails INP in Search Console. Why?
Lighthouse doesn’t measure INP during a standard page load test, because there are no user interactions. It reports Total Blocking Time as a proxy. Real users interact, so field data reveals problems Lighthouse can’t.
Does a caching plugin improve INP?
Not directly. Caching speeds up server response. INP is about JavaScript and rendering in the browser after the page loads.
Is jQuery itself the problem?
Loading jQuery costs some time, but it’s rarely the main cause. The bigger issue is what plugins do with it, especially heavy work on page load and in event handlers.
Will removing my chat widget really help?
Often yes. Many chat widgets load several hundred kilobytes of JavaScript and run continuously. Loading them only when someone clicks a chat button is a common and effective fix.




