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.

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.
What you need
Step-by-step fix
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.
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.
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(orasyncfor 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.
<!-- 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>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.
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;
}
}
}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.
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);
});
});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: autoto long below-the-fold sections so they are not rendered until needed. - Animate only
transformandopacity.
.product-reviews,
.site-footer,
.related-posts {
content-visibility: auto;
contain-intrinsic-size: auto 800px;
}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.
<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>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.
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 freeFAQ
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.
How to Fix Cumulative Layout Shift (CLS) on Your Website
How to Fix a Slow Largest Contentful Paint (LCP) on Mobile
How to Fix Slow Time to First Byte (TTFB) on Your Website
How to Fix a Missing or Unhelpful Custom 404 Page
How to Fix Total Page Weight: Get Your Homepage Under 2 MB
How to Fix Soft 404 Pages and Return a Real 404 Status