Say you are trying to fix a “Poor” INP score flagged in Search Console. The report tells you the metric is bad, and it might even point to a specific page template. What it does not tell you is which of the dozen scripts running on that page is responsible, or why a button click that feels instant on your development machine takes 400 milliseconds to respond on a mid-range Android phone.

This is the frustrating part of Interaction to Next Paint (INP). Unlike a layout shift you can visually spot, or an image that obviously takes too long to load, INP problems live inside the main thread’s execution timeline. You cannot see them without opening the right tools and knowing what you are looking for.

This guide is structured as a troubleshooting checklist. For each common symptom, we will walk through the likely cause and the concrete fix. Work through it in order, since the issues near the top tend to have the biggest impact on real-world scores.


Fixing Bad INP Scores: A Symptom-Cause-Fix Guide to Reducing Main Thread Work

Symptom: The Performance Panel Shows Long Tasks Before the Interaction Even Happens

You open Chrome DevTools, go to the Performance panel, record a click, and notice something odd: the input delay (the gap between the click and when your event handler starts) is huge, but your actual click handler runs quickly.

Cause: Main Thread Congestion from Unrelated Work

INP is not only about how fast your click handler executes. It is measured from the moment the user interacts to the moment the next frame is painted. If the main thread is busy running something unrelated — a third-party analytics script, a background data-processing loop, a large JSON.parse() call — when the user clicks, the browser cannot even start your handler until that unrelated task finishes.

This is the single most common cause of poor INP on content-heavy sites, and it is frequently invisible in synthetic Lighthouse audits because those don’t simulate real user interaction timing under load.

Fix: Break Up Long Tasks

Any JavaScript task that runs for more than 50ms is classified as a “long task” and blocks the main thread from responding to input. The fix is to chunk large synchronous operations into smaller pieces using a scheduling API.

// Before: one long, blocking task
function processLargeArray(items) {
  items.forEach(item => heavyComputation(item));
}

// After: yield to the main thread between chunks
async function processLargeArrayInChunks(items) {
  for (let i = 0; i < items.length; i++) {
    heavyComputation(items[i]);
    if (i % 20 === 0) {
      await new Promise(resolve => setTimeout(resolve, 0));
      // Or, in supporting browsers:
      // await scheduler.yield();
    }
  }
}

Yielding periodically gives the browser a chance to process pending input and paint updates before your script resumes.


Symptom: Clicking a Button Feels Sluggish, But Only on Certain Pages

You test the same UI component on a simple page and it feels instant. On a page with a complex dashboard or a long product listing, the identical component feels laggy.

Cause: An Oversized DOM Combined with Expensive Style Recalculations

A large DOM (thousands of nodes) doesn’t just slow down initial rendering. It slows down every subsequent interaction, because any DOM mutation your click handler triggers — adding a class, toggling visibility, updating text — can force the browser to recalculate styles and layout for a much larger tree than necessary.

This shows up in the Performance panel as “Recalculate Style” and “Layout” entries nested inside your event handler’s callstack, often taking far longer than the JavaScript itself.

Fix: Scope Your DOM Changes and Reduce Node Count

Two changes work together here. First, audit whether the page needs every node currently rendered — virtualize long lists so only visible items exist in the DOM. Second, when you do need to update the DOM in response to an interaction, keep the change as localized as possible.

  • Avoid reading layout properties (offsetWidth, getBoundingClientRect()) immediately after writing to the DOM, which forces a synchronous layout recalculation.
  • Batch DOM reads and writes separately instead of interleaving them in a loop.
  • Use content-visibility: auto on off-screen sections to reduce the rendering work the browser has to account for.

In testing, reducing DOM node count on a large listing page from roughly 8,000 to 2,500 nodes cut style recalculation time inside click handlers by more than half.


Symptom: The Delay Happens After Your Click Handler Finishes Running

This one confuses developers the most. You’ve profiled your handler, it completes in 5ms, yet the INP measurement for that interaction is still 300ms+.

Cause: Rendering Work Queued for the Next Frame

INP measures the full pipeline: input delay, processing time, and presentation delay (the time to paint the next frame). If your click handler triggers a state update that causes a large re-render — think a framework like React or Vue re-rendering a large component tree — that rendering work happens after your handler returns, but it still counts against the interaction’s total duration.

Fix: Defer Non-Critical Rendering Work

Not every update triggered by a click needs to happen in the same frame. Use startTransition in React (or equivalent low-priority scheduling in other frameworks) to tell the renderer which updates are urgent (visual feedback like a button’s pressed state) and which can wait (re-rendering a large results list).

import { startTransition } from 'react';

function handleFilterClick(newFilter) {
  setActiveButton(newFilter); // urgent: immediate visual feedback
  startTransition(() => {
    setFilteredResults(computeResults(newFilter)); // can be deferred
  });
}

This separation lets the browser paint the immediate feedback quickly while the heavier work is scheduled with lower priority, keeping the perceived response time short even if the full update takes longer.


Symptom: Third-Party Scripts Are the Top Entry in Every Long Task Report

You filter the Performance panel by script source and notice that a chat widget, a customer-data-platform tag, or an ad script dominates the “Total Blocking Time” attribution — often more than your own application code combined.

Cause: Uncontrolled Third-Party Execution

Third-party scripts frequently run on their own schedule, unaware of when your users are trying to interact with the page. A tag manager firing a batch of analytics events, or a widget re-initializing itself on every route change, competes directly with your own event handlers for main thread time.

Fix: Isolate and Delay Third-Party Work

You have three practical levers here, roughly in order of effectiveness:

  1. Move what you can off the main thread. Some third-party scripts (particularly analytics and tag managers) support execution inside a Web Worker via a facade like Partytown, which proxies DOM access without blocking the main thread.
  2. Delay initialization until after the page is interactive. Load non-critical third-party scripts using requestIdleCallback or after a fixed delay, rather than eagerly on page load.
  3. Audit and remove. It’s worth periodically asking whether every tag still serves a business purpose. Consolidating five overlapping analytics scripts into one measurably reduces main thread contention.

Symptom: INP Is Fine in the Lab but Poor in the Field (CrUX Data)

Lighthouse gives you a good score locally, but the Core Web Vitals report in Search Console — built from real user data — shows a “Needs Improvement” or “Poor” rating for the same page.

Cause: Device and Network Diversity You Aren’t Testing Against

Lab tools typically run on a fast development machine or a moderately throttled CI environment. Field data (CrUX) aggregates real visits, including a large share of low-end and mid-tier mobile devices with far less CPU headroom. A task that takes 30ms on your laptop can take 150ms or more on a budget Android device.

Fix: Test Under Realistic CPU Throttling and Segment by Device

In Chrome DevTools, apply 4x or 6x CPU throttling in the Performance panel to approximate a mid-tier mobile device before drawing conclusions from a trace. Beyond that:

  • Use the Chrome UX Report (CrUX) API or the web-vitals JavaScript library to collect field INP data segmented by device type.
  • Prioritize fixes for interactions that appear on high-traffic pages accessed predominantly from mobile devices, since that’s where the gap between lab and field scores tends to be largest.
  • Re-test fixes with throttling enabled — a fix that shaves 10ms off an already-fast desktop interaction won’t move the needle on a field score dominated by slower devices.

Quick Reference Checklist

SymptomLikely CausePrimary Fix
Input delay is high before handler startsMain thread congestion from long tasksBreak up long tasks with yielding
Sluggish only on complex pagesOversized DOM / layout thrashingReduce node count, batch DOM reads/writes
Delay occurs after handler completesDeferred rendering work counted in INPUse startTransition or equivalent scheduling
Long tasks attributed to third-party scriptsUncontrolled third-party executionOffload to a worker, delay init, or remove
Good lab score, poor field scoreUntested device/network diversityThrottle CPU in testing, segment field data

Work through this list against your own traces rather than assuming which cause applies. In most cases, a poor INP score is the result of two or three of these issues compounding rather than a single dramatic bug — which is exactly why fixing the top offender first, then re-measuring, tends to produce more reliable progress than trying to solve everything at once.

Related guides: Web Workers vs. Debouncing: The Real Fix for Slow INP Scores, The Overlooked Performance Killer: How to Shrink Your JavaScript with Code Splitting and Tree Shaking, and Your DOM Has a Weight Problem: A Step-by-Step Guide to Fixing Excessive DOM Size.