How to Fix Interaction to Next Paint (INP) Above 200ms

Interaction to Next Paint (INP) measures how long your page takes to visually respond after a click, tap or key press. The value reported is roughly the slowest interaction across a visit, measured at the 75th percentile of real Chrome users. By the end of this guide you will have found the scripts blocking your main thread, split up or deferred that work, and confirmed the improvement in PageSpeed Insights.

By Updated ⏱ 2–6 hours of work, plus up to 28 days for field data to update🎯 Advanced● High impactTechnical
Illustration: Interaction to Next Paint (INP) fix guide
TECHNICAL · FIX GUIDE Interaction to Next Paint (INP) IMPACTEFFORT TIME2–6 hours of work, plus up to 28 days for field data to update LEVELAdvanced

Why it matters

INP is one of Google's three Core Web Vitals, so a 'Poor' rating (over 500ms) or 'Needs improvement' rating (200–500ms) counts against your page experience signals in Search. The bigger cost is with users. When a menu, add-to-cart button or form field takes half a second to react, people tap again, abandon the form or assume the site is broken.

If Chrome has no field data for your page, the audit falls back to lab Total Blocking Time (TBT). TBT is driven by the same long JavaScript tasks, so the fixes below lower both numbers.

✕BeforePageSpeed Insights field data: INP640ms (Poor). Lab TBT is 1,150msbecause of a chat widget, two✓AfterPageSpeed Insights field data: INP160ms (Good). Lab TBT is 120ms,third-party tags load after

What you need

Chrome desktop with DevTools
Access to your theme, template or tag manager to edit or remove scripts
PageSpeed Insights (pagespeed.web.dev) and, ideally, Google Search Console
A developer comfortable with JavaScript for the code-level steps

Step-by-step fix

1

Measure your current INP and TBT baseline

dev. In the Discover what your real users are experiencing section, note the INP value for This URL. If that section says there is not enough data, check the Origin tab.

The audit scores field INP first: under 200ms passes, and over 500ms fails. If no field INP exists, it scores lab Total Blocking Time instead: under 200ms passes, and over 600ms fails. Also open Google Search Console > Experience > Core Web Vitals to see which URL groups have INP issues on mobile versus desktop.

Pro tip: Test the mobile result first. INP is almost always worse on mid-range Android phones, and those users dominate the 75th percentile.
2

Find the slow interactions in Chrome DevTools

Open the page in Chrome and open DevTools (F12). Go to the Performance panel and set CPU throttling to 4x slowdown (or the calibrated mid-tier mobile preset). The Live metrics view shows INP as you click menus, filters, accordions and buttons.

Each interaction is listed with its duration. Record a trace while repeating the slowest interaction. In the Main track, look for long tasks (red-flagged, over 50ms) and expand them to see which script and function used the time.

Each interaction breaks down into three parts:

  • Input delay: other work was already running when the user clicked.
  • Processing duration: your event handlers are slow.
  • Presentation delay: rendering, style or layout after the handler is slow.
Pro tip: Sort the Bottom-Up tab by Self Time and group by Domain. This quickly shows how much main-thread time belongs to third parties versus your own code.
3

Defer or remove third-party scripts

Third-party tags are the most common cause of high input delay. Chat widgets, A/B testing tools, heatmaps, social embeds and duplicate analytics are frequent offenders.

  • Remove any tag that no one actively uses.
  • Add defer (or async for independent scripts) to the rest.
  • Load heavy widgets only after the user shows intent, such as the first scroll, click or key press.

In Google Tag Manager, move non-essential tags from the Initialization or Page View trigger to Window Loaded, or to a custom trigger.

html
<!-- Load a chat widget only after the first user interaction -->
<script>
  (function () {
    var loaded = false;
    function loadChat() {
      if (loaded) return;
      loaded = true;
      var s = document.createElement('script');
      s.src = 'https://chat.example.com/widget.js';
      s.async = true;
      document.head.appendChild(s);
    }
    ['pointerdown', 'keydown', 'scroll'].forEach(function (evt) {
      window.addEventListener(evt, loadChat, { once: true, passive: true });
    });
  })();
</script>
<script src="/js/analytics.js" defer></script>
Pro tip: Replace an embedded YouTube iframe or map with a static image (a facade) that loads the real embed on click. This often removes 300ms or more of main-thread work.
4

Break up long tasks by yielding to the main thread

Any task over 50ms blocks input. Split long loops and initialisation code into chunks, and yield between them so the browser can handle clicks. yield()` where it is supported (Chromium-based browsers).

Fall back to setTimeout elsewhere. Yield after each logical unit of work, or whenever roughly 50ms has passed.

javascript
function yieldToMain() {
  if (globalThis.scheduler && typeof scheduler.yield === 'function') {
    return scheduler.yield();
  }
  return new Promise(resolve => setTimeout(resolve, 0));
}

async function processItems(items) {
  let deadline = performance.now() + 50;
  for (const item of items) {
    renderItem(item);
    if (performance.now() > deadline) {
      await yieldToMain();
      deadline = performance.now() + 50;
    }
  }
}
Pro tip: Use the Long Animation Frames API (the PerformanceObserver entry type 'long-animation-frame') in production. It shows which script URLs cause long frames for real users.
5

Make event handlers paint first, then do the heavy work

Inside a click or input handler, do only the work needed for visual feedback. Examples are toggling a class, showing a spinner or opening the menu. Move analytics calls, data processing and network requests to after the next paint.

Debounce handlers on input and keydown so search-as-you-type does not run on every keystroke.

javascript
button.addEventListener('click', () => {
  // 1. Immediate visual feedback
  menu.classList.toggle('is-open');

  // 2. Defer non-urgent work until after the next frame is painted
  requestAnimationFrame(() => {
    setTimeout(() => {
      sendAnalytics('menu_toggle');
      prefetchMenuData();
    }, 0);
  });
});
Pro tip: In React, wrap expensive state updates in startTransition (or use useDeferredValue). The urgent UI update then renders first.
6

Reduce rendering and DOM cost

If DevTools shows a high presentation delay, the browser is spending too long on style, layout and paint after your handler runs.

  • Keep the DOM under roughly 1,500 elements where possible.
  • Avoid reading layout properties (offsetHeight, getBoundingClientRect) right after writing styles in the same loop. This causes layout thrashing.
  • Add content-visibility: auto to long below-the-fold sections so they are not rendered until needed.
  • Animate only transform and opacity.
html
.product-reviews,
.site-footer,
.related-posts {
  content-visibility: auto;
  contain-intrinsic-size: auto 800px;
}
Pro tip: Lighthouse's 'Avoid an excessive DOM size' diagnostic lists the deepest and largest nodes. Mega-menus and hidden mobile duplicates of the navigation are typical culprits.
7

Add field monitoring with the web-vitals library

Lab tests cannot reproduce every real interaction, so collect INP from real users. The web-vitals attribution build reports which element was clicked and how the delay splits into input delay, processing and presentation. Send this data to your analytics tool, then fix the slowest selectors first.

html
<script type="module">
  import { onINP } from 'https://unpkg.com/web-vitals@4/dist/web-vitals.attribution.js?module';
  onINP(({ value, rating, attribution }) => {
    navigator.sendBeacon('/vitals', JSON.stringify({
      metric: 'INP',
      value: Math.round(value),
      rating,
      target: attribution.interactionTarget,
      inputDelay: Math.round(attribution.inputDelay),
      processing: Math.round(attribution.processingDuration),
      presentation: Math.round(attribution.presentationDelay)
    }));
  });
</script>
Pro tip: For production, self-host the web-vitals package through npm rather than loading it from a CDN.
8

Re-test and confirm the result

Deploy your changes and clear any page or CDN cache. dev. Lab Total Blocking Time should drop immediately.

Field INP comes from the Chrome UX Report's rolling 28-day window, so it improves gradually over about four weeks. In Search Console's Core Web Vitals report, open the failing issue and click Validate fix to start Google's 28-day validation.

Pro tip: Re-test the same slow interactions in the DevTools Live metrics view with 4x CPU throttling. Each one should now show under 200ms.

Platform-specific notes

WordPress

Most INP problems come from plugins that enqueue JavaScript sitewide, such as sliders, page builders, chat and popups. Use Asset CleanUp or Perfmatters' Script Manager to unload scripts on pages that do not need them. You can also use WP Rocket (Settings > WP Rocket > File Optimization > **Delay JavaScript execution**) or FlyingPress to delay third-party scripts until user interaction. Test menus and forms afterwards, because delayed scripts can break functionality.

Shopify

Each installed app can inject storefront JavaScript. Go to Online Store > Themes > Customize > **App embeds** and switch off embeds you do not use. Then uninstall unused apps entirely, because some leave code behind in theme.liquid. Check Online Store > Themes > Edit code > layout/theme.liquid for leftover script tags. Prefer Online Store 2.0 themes that use native web components over jQuery-heavy themes.

Wix

You cannot edit core platform scripts. Focus on what you control. Remove unused Wix apps, limit heavy elements (galleries, embedded HTML iframes, animations) on key pages, and keep Velo code in onReady light. Move tracking pixels into Settings > **Marketing Integrations** or **Custom Code** set to load at 'Body - end'.

Webflow

Check Site settings > **Custom code** and each page's settings for third-party scripts. Add defer to them, or move them to the 'Before </body> tag' field. Complex Interactions (scroll and click animations on many elements) add main-thread work, so simplify or remove them on mobile breakpoints.

Next.js

Load third-party tags with next/script using strategy="lazyOnload" for chat and widgets, or "afterInteractive" for analytics. Use React's startTransition or useDeferredValue for expensive state updates. Code-split heavy components with next/dynamic. Reduce client-side hydration by keeping components as Server Components unless they need interactivity.

Check that it worked

✅ How to verify

  • Re-run pagespeed.web.dev for the URL. Field INP should be under 200ms ('Good'). If no field data exists, lab Total Blocking Time should be under 200ms.
  • In Chrome DevTools > Performance > Live metrics, with 4x CPU throttling, click your key buttons, menus and form fields. Each interaction should be under 200ms, with no long tasks over 50ms around it.
  • After about 28 days, check that Search Console > Experience > Core Web Vitals shows the affected URL groups moved to 'Good' and that the Validate fix check passed.
  • Confirm your web-vitals field data shows a 75th-percentile INP under 200ms on mobile.

⚠️ Common mistakes

  • Testing only on a fast desktop without CPU throttling. Real-user INP is driven by mid-range phones, so lab results look far better than field data.
  • Expecting PageSpeed Insights field data to change the same day. CrUX uses a 28-day rolling window, so only lab TBT reflects changes immediately.
  • Delaying all JavaScript with a performance plugin, including scripts the menu, cart or consent banner needs. This can break interactions or make the first click wait for a large script download.
  • Optimising only the homepage when INP problems are usually on interactive templates, such as product filters, checkout, search and long article pages with embeds.

Is this still an issue on your site? Run a free audit — ZORO checks this and 294 other SEO, AI-visibility, accessibility and security signals, with fixes for your platform.

Check my site free

FAQ

What is a good INP score?

Google rates INP at or under 200ms as Good, 200–500ms as Needs improvement, and over 500ms as Poor. It is measured at the 75th percentile of real page visits, so most of your users need fast interactions, not just the average user.

Why does PageSpeed Insights show TBT instead of INP for my page?

INP needs real user interactions, so it only appears when the Chrome UX Report has enough traffic data for your URL or origin. Lighthouse lab tests cannot click anything, so Total Blocking Time is used as a proxy. TBT measures how long the main thread is blocked during load, and it is caused by the same long tasks.

How long does it take for INP improvements to show in Search Console?

Search Console and PageSpeed Insights field data use a rolling 28-day window of Chrome user data. Expect gradual improvement over two to four weeks after deploying. Clicking Validate fix in Search Console starts a 28-day monitoring period.

Does Google Tag Manager hurt INP?

GTM itself is light, but the tags it fires often are not, especially heatmaps, A/B testing tools, chat widgets and multiple ad pixels. Audit the container, remove unused tags, and fire non-essential tags on Window Loaded or after user interaction instead of on page initialisation.