How to Improve INP: A Field-to-Fix Checklist for Developers

To improve INP, find the one interaction that is slow, then fix whichever of its three parts is slow: input delay, processing duration or presentation delay. Cutting JavaScript at random can miss the slow part entirely, so you need to find it first. This checklist follows a field-to-fix order: field data, then a DevTools recording, then a fix matched to the slow part. A good Interaction to Next Paint (INP) is 200 ms or less, and anything above 500 ms is poor.

Key takeaways

  • Read INP at the 75th percentile, split by mobile and desktop. Good is 200 ms or less, poor is above 500 ms.
  • PageSpeed Insights shows the CrUX value but not the slow interaction. Add the web-vitals library to find it.
  • Record the exact tap in the Chrome DevTools Performance panel with CPU throttling, and read input delay, processing duration and presentation delay.
  • On WordPress, switch off one page builder feature, chat widget or Google Tag Manager tag at a time and re-measure.

How to improve INP without guessing: start with field data

Start in Search Console, not in your code. INP is a Core Web Vitals field metric, and web.dev defines it at the 75th percentile of page loads, segmented across mobile and desktop (web.dev, Interaction to Next Paint (opens in a new tab)). A page is good at 200 ms or less, needs improvement above 200 ms up to 500 ms, and is poor above 500 ms.

That percentile matters. INP is not your single worst click. web.dev says INP ignores one highest interaction for every 50 interactions, and then reports the 75th percentile of all page views. One freak delay on your test machine tells you little about the value Google sees for your site.

  1. Open the Core Web Vitals report in Search Console. Note which URL groups fail on INP and whether the failure is on mobile, desktop or both. Check the two separately, because phones and desktops can give you different INP values.
  2. Run one URL from each failing group through PageSpeed Insights. Read the CrUX (Chrome User Experience Report) value at the 75th percentile.
  3. Find the interaction. CrUX gives you a number without context. web.dev recommends a Real User Monitoring (RUM) provider or your own RUM code to get the specific interaction, its type and whether it happened during or after load (web.dev, INP fix guide (opens in a new tab)).

If a page gets no clicks, taps or key presses from users, it returns no INP value at all. A page that shows nothing in the report is not necessarily fast. It may simply be unmeasured.

For your own RUM, the web-vitals library reports the three subparts for each interaction. Check the official docs for the version you install, since the attribution fields have changed between major versions.

JavaScript
import {onINP} from 'web-vitals/attribution';

onINP((metric) => {
  const a = metric.attribution;
  console.log(metric.value, a.interactionTarget,
    a.inputDelay, a.processingDuration, a.presentationDelay);
});

Record the slow interaction in Chrome DevTools and read its three parts

Open the Performance panel, throttle the CPU, and perform the exact tap, click or key press that RUM flagged. Then read the interaction in the Interactions track. Your laptop is faster than the phones in your field data, so an unthrottled test often shows nothing wrong.

Work through the recording in this order:

  1. Open the page in an Incognito window so extensions do not add tasks.
  2. In Performance, turn on CPU throttling and start recording.
  3. Do the exact interaction from your field data. If RUM says it happens during load, interact while the page is still loading, when the main thread is busiest.
  4. Stop recording and click the interaction in the Interactions track.
  5. Write down the three numbers: input delay, processing duration, presentation delay.

web.dev defines the three parts. Input delay runs from the user’s action until event callbacks begin. Processing duration is the time those callbacks take. Presentation delay is the time until the browser paints the next frame (web.dev, INP fix guide (opens in a new tab)). Add them up and you have the interaction latency.

Note: Each iframe has its own main thread, and INP counts slow interactions inside iframes on the page. Check which frame the interaction happens in. A tap inside an embedded chat or video widget will not show up in the top-level page’s thread, and that is one reason CrUX and RUM numbers can differ.

I have not attached lab numbers from a specific site here. Every threshold and definition in this article comes from the web.dev pages linked above.

Match the slow part to its cause before you change code

The largest of the three numbers tells you where to work. Fix that part first, because shaving 20 ms off a part that takes 30 ms will not move the page out of the poor range.

Slow partUsual causeFirst fix
Input delayLong tasks on the main thread, often startup scripts still being parsed, compiled and runDefer or remove startup scripts, split long tasks
Processing durationHeavy event handlers doing too much work per tapDo less in the handler, yield between chunks
Presentation delayExpensive rendering after the handler, often a large DOMReduce DOM size, limit what changes per interaction
Any part, but only in an iframeThird-party widget with its own main threadDelay, replace or remove the embed

web.dev notes that script evaluation after download (parse, compile, execute) can create long tasks that stop the browser from answering interactions during load (web.dev, INP fix guide (opens in a new tab)). That is why a page can feel fine after ten seconds and still fail when a user taps early.

Break up long tasks and cut work inside event handlers

In the DevTools trace, look for tasks longer than 50 ms that sit in front of or inside your interaction. Split them into smaller tasks and yield to the main thread between chunks, so the browser can paint and handle the next tap. Long JavaScript tasks add to input delay and slow processing.

The best general advice from web.dev is to do as little work as possible in event callbacks. If the logic cannot shrink, break it into separate tasks. A setTimeout callback runs in a new task, so it works as a yield point (web.dev, INP fix guide (opens in a new tab)).

Yield after the code that updates the interface, not before it. The user sees the visual result sooner when rendering runs first and the rest of the work follows.

JavaScript
function yieldToMain() {
  if (globalThis.scheduler?.yield) {
    return scheduler.yield();
  }
  return new Promise((resolve) => setTimeout(resolve, 0));
}

button.addEventListener('click', async () => {
  showSpinner();          // visual feedback first
  await yieldToMain();    // let the browser paint
  await saveCart();       // heavy work after the paint
  await yieldToMain();
  sendAnalytics();        // non-urgent work last
});

Move non-urgent startup work later, too. Analytics, A/B tests and social embeds rarely need to run before the first tap. Check scheduler.yield support for your audience in the official docs before you rely on it, and keep the setTimeout fallback.

On WordPress, test page builders, chat widgets and tag managers one at a time

Page builders, chat widgets and tag managers add third-party or plugin code to your site, so test them first. Use this procedure for each one:

  1. Open the slow page in Chrome DevTools and set the same CPU throttling you will use for every run.
  2. Record the slow interaction and note input delay, processing duration and presentation delay.
  3. Disable one item only.
  4. Record the same interaction again with the same throttling and compare the three parts.

The three groups fail in different ways:

  • Page builders (Elementor, Divi and similar) add front-end scripts and markup. Check input delay at load, and presentation delay on pages with deep nesting.
  • Chat widgets may sit in an iframe with their own main thread, so check which frame the slow tap happens in. A tap on the chat bubble is still an interaction on your page.
  • Tag managers run every tag in the container. Use the preview mode in Google Tag Manager, pause tags one by one and repeat the recording.

To find which plugin loads a script, open the Network tab, select the script and read its Initiator and URL. A path under /wp-content/plugins/ names the plugin.

In our work, the most common expensive mistake is choosing a plugin without considering its compatibility with other plugins and the hosting environment, which leads to performance issues or conflicts. So change one plugin at a time, on a staging copy, and record the result before you touch the next one.

Warning: A caching or performance plugin that delays all JavaScript until first user input can move the cost to the first tap. The queued scripts then run together as one long task, and input delay for that tap can jump. Re-record the interaction after you switch the setting on.

Next step: reproduce one interaction today, then read the official docs

Pick the worst failing URL group in Search Console. Run one URL through PageSpeed Insights, record one slow interaction in DevTools with CPU throttling, and write down which of the three parts is largest. That one number decides whether you work on startup scripts, handlers or rendering.

Then read web.dev’s guide to fixing INP (opens in a new tab) for the section that matches your slow part, and re-check the Core Web Vitals report after the fix has been live long enough for field data to update.

Frequently Asked Questions

What is a good INP score in Core Web Vitals?

A good INP is 200 ms or less at the 75th percentile of page loads. Above 200 ms up to 500 ms needs improvement, and above 500 ms is poor (web.dev, Interaction to Next Paint (opens in a new tab)). Read mobile and desktop separately, because they can differ.

How do I improve INP on a page that already looks fast?

Check field data first, because your own machine is faster than the phones your visitors use. Record the flagged interaction in Chrome DevTools with CPU throttling on, then work on the largest of input delay, processing duration and presentation delay. Fixing the smallest part will not move the score.

Why does PageSpeed Insights show no INP value for my page?

A page that gets no clicks, taps or key presses from users returns no INP value. A blank result means unmeasured, not fast. Use RUM code such as the web-vitals library to collect interactions yourself.

Which part of INP should I fix first?

Fix the largest of the three numbers. Long tasks and startup scripts point to input delay, heavy event handlers point to processing duration, and a large DOM or costly rendering points to presentation delay (web.dev, INP fix guide (opens in a new tab)).

Can a WordPress plugin hurt my INP?

Yes. Page builders, chat widgets, tag managers and plugins that delay JavaScript until first input can all add main thread work. Disable one at a time on a staging copy, record the same interaction with the same CPU throttling, and compare the three parts.

Why do my DevTools numbers differ from the Search Console report?

Search Console shows field data at the 75th percentile across real visits, while a DevTools recording shows one interaction on one machine. Interactions inside iframes also run on their own main thread, which can make CrUX and RUM numbers differ from what you see in the page’s own trace.