How to Fix INP in WordPress

Interaction to Next Paint, or INP, measures how responsive a page feels when people click, tap, or type. A WordPress page can load quickly and still have poor INP if JavaScript keeps the main thread busy when the visitor tries to interact.

The main job is to find the slow interaction and the work that runs around it. Do not try to fix INP by changing image compression or adding page cache unless the evidence shows those changes affect the interaction.

Start with field data

INP is based on real interactions, so field data is especially useful. PageSpeed Insights can show CrUX INP data when enough real-user data exists. A real-user monitoring tool can go further by telling you which element was used, which event fired, and what happened around the delay.

If field data says INP is poor, reproduce the important interactions in a lab. Test the menu, search, filters, accordions, forms, cart controls, tabs, popups, and any button users touch often.

Our guide to testing WordPress speed explains how lab and field data fit together.

Understand what creates interaction delay

A slow interaction can have several parts. The browser may wait before it can start the event handler because another long task is already running. The event handler itself may do too much JavaScript. After the handler runs, the browser may still need expensive style, layout, and paint work before the next frame appears.

This is why a small button script can feel slow when a different third-party script is blocking the main thread at the same time.

Find long JavaScript tasks

Use the browser performance panel to record a slow interaction. Look for long tasks on the main thread and expand them to find the scripts and functions involved.

Large bundles, page-builder code, sliders, analytics, tag managers, ads, chat widgets, consent managers, and social embeds can all create long tasks. Some of that code may run during page load. Some may run only when the user interacts.

Remove scripts that add little value. A script you remove is cheaper than one you defer, split, or minify.

Reduce third-party JavaScript

Third-party code is hard to control because it can change without a WordPress update. A vendor can add more code, make a slower network request, or change how often a script runs.

Audit each third-party tool by purpose. Keep the ones that earn their cost. Delay non-critical tools until after the main content is ready or until the user reaches the feature that needs them. Our third-party JavaScript guide gives a practical method.

Do not load every feature on every page

Many WordPress plugins enqueue scripts globally even when only one page needs the feature. A gallery plugin may load on articles with no gallery. A form plugin may load on every page even though the form appears only on Contact.

Where it is safe, unload or conditionally enqueue assets so each template pays only for what it uses. Do this carefully. A script that looks unused on initial load may be needed for a menu, popup, or late interaction.

Break up heavy work

Long synchronous work blocks the main thread. If custom JavaScript processes a large list, builds a complex interface, or handles a large data set in one task, split the work into smaller pieces so the browser can respond between them.

For custom development, use modern scheduling patterns and avoid doing large amounts of work inside one click handler. Update only the part of the DOM that changed instead of rebuilding a whole section.

Keep event handlers small

A click should not trigger a chain of unrelated work. If one handler validates a form, sends analytics, rebuilds a component, reads layout several times, and starts a remote request before giving visual feedback, the visitor feels the delay.

Give immediate feedback first when possible. Move non-urgent work out of the critical interaction path. Batch DOM reads and writes instead of forcing repeated layout calculations.

Watch page builders and interactive widgets

Complex builders can create many DOM nodes and attach many event listeners. Mega menus, filters, carousels, popups, sticky effects, animations, and nested tabs can add interaction work even when they look simple.

Test the page with optional widgets disabled on a staging copy. Keep the visual features that matter and remove effects that add cost without helping the reader.

Reduce DOM size when it is extreme

A very large DOM can make style and layout work more expensive. This often happens with deeply nested page-builder layouts, large menus, hidden duplicate sections for different screen sizes, and long lists rendered all at once.

Do not rebuild a whole site just because the DOM is large, but simplify obvious duplication. Use CSS for responsive layout instead of shipping separate desktop and mobile copies of the same large section when possible.

Be careful with delayed JavaScript settings

Speed plugins may offer “delay all JavaScript until interaction.” This can raise a lab score, but it can also make the first interaction do too much work at once. The visitor taps a menu, then the browser suddenly has to initialize half the site before the menu can respond.

Delay only scripts that can safely wait. Keep essential interaction code ready before the visitor needs it.

Check WordPress admin INP separately

CrUX does not measure private WordPress admin screens the same way it measures public pages, but the same idea applies: long JavaScript tasks and heavy DOM work make the dashboard feel sticky.

If admin pages are slow before the click is even processed, also inspect server response, queries, object cache, and plugin hooks. The public-site INP fix may not solve a slow order editor.

Use performance features as tools, not magic

The WordPress Performance Team ships and tests performance features through Performance Lab and related plugins. These projects can improve loading behavior, image handling, and other parts of the stack, but they do not replace a site-specific diagnosis.

Keep WordPress current and test new performance features on staging when they affect navigation or script behavior.

A practical INP workflow

  1. Confirm poor INP in field data when available.
  2. List the interactions that matter most.
  3. Record a slow interaction in browser developer tools.
  4. Find long tasks and the scripts that own them.
  5. Remove or delay low-value third-party code.
  6. Unload plugin assets from pages that do not need them.
  7. Break custom work into smaller tasks.
  8. Retest on a slower mobile profile.
  9. Watch field data after the change.

If the problem is really first paint rather than interaction, move to the WordPress LCP guide instead.

Look for work that starts just before the interaction

The script that handles a click is not always the script that caused the delay. A timer, ad refresh, analytics task, animation, or background component may start a long task a moment before the visitor taps. In a performance recording, inspect the main thread around the input event, not only the event handler itself.

This matters on WordPress pages with several independent plugins. A menu plugin may be blamed for a slow menu even though an ad script or consent tool blocked the main thread at the same time.

Measure the cost of style and layout

INP includes the time until the next paint, so the browser’s rendering work matters too. A handler that adds one class can still trigger expensive style calculations if the page has a huge DOM or complex selectors. Layout can become costly when scripts repeatedly read geometry and then write styles in a loop.

In custom code, group DOM reads and writes. Avoid forcing layout again and again. In builder-heavy pages, simplify deeply nested sections and hidden duplicate layouts when they create measurable rendering cost.

Retest the first interaction after page load

The first tap can be worse than later taps because the browser is still running startup work. Test a menu or button immediately after the page looks ready, then test it again after several seconds. If only the first interaction is slow, delay or reduce startup JavaScript rather than optimizing the handler alone.

Also test keyboard input and form fields. Search boxes, live validation, address lookup, and product filters can run code on every keystroke. Debounce work that does not need to run for each key and avoid sending a network request before the user has paused long enough for it to be useful.

Sources and further reading

Related FastWP guides