Skip to content
Faisal Mahmud TusherDigital marketing, SEO & analytics
with Faisal Tusher

SEO › Troubleshooting

INP Issue: Slow Interactions

Why pages fail Interaction to Next Paint and how to fix it: long main-thread tasks, heavy handlers, third-party scripts, layout work and late hydration.
Troubleshootingintermediate8 min readUpdated

First, find which interaction is slow and on which devices

Begin with the Core Web Vitals report (Core Web Vitals) in Search Console, which the report's help page describes as grouping URLs by similar behaviour from real-user data. INP problems are usually mobile problems, so read the mobile tab first, note the failing group, and identify the template its example pages share. Responsiveness depends on what visitors do, so ask what they do on that template: open a menu, apply a filter, change a variant, add to basket, type into a search field.

Then reproduce it. Open an example page on a throttled mobile processor and record in the performance panel while performing those interactions. For each slow one, the recording shows the interaction and the work around it; web.dev describes the metric as measuring the delay until the next paint after an interaction, and the trace splits that delay into three parts. A long input delay means the main thread was busy with something else when the tap arrived. A long processing time means the handler itself was slow. A long presentation delay means the browser spent its time on style, layout and paint after the handler finished. Where the site runs real-user monitoring that reports the interaction target, use it to confirm the lab finding. Then read the matching row.

Diagnosis table

Diagnosis

SymptomCheckLikely causeFix
Long input delay; unrelated long tasks running when the tap arrivesLong tasks in the trace around the interaction and what script they belong toLong JavaScript tasks blocking the main threadSplit long tasks and yield to the browser between chunks
Short input delay but long processing inside the click or input handlerThe handler's own call tree in the traceHeavy event handlers doing work before the next paintPaint the visible response first, defer the rest, move heavy work off the main thread
Long tasks attributed to tag, chat, testing or advert domainsThird-party script attribution in the trace; the tag manager containerThird-party tags, chat and ad scripts competing for the main threadRemove unused tags, delay others until idle or interaction, govern additions
Long presentation delay with large style and layout entriesRendering work after the handler; the number of elements affectedLayout and rendering work triggered by each interactionReduce the work each update causes; avoid forced layout and large DOM changes
Early taps are slow, later ones fine; framework start-up dominatesHydration and script evaluation in the first seconds of the traceHydration on script-heavy pages delaying the first responsesShip less script, hydrate selectively or progressively, render more on the server

Fix, verify and prevent each cause

A main thread that is never free

The browser can respond to a tap only when the main thread is between tasks. A long task, whether parsing a large bundle, building a carousel or processing analytics, keeps the visitor waiting even if the code it runs has nothing to do with what they tapped. That is input delay, and it is the part most often blamed on the wrong code.

Fix: break long tasks into smaller chunks that yield to the browser between them, defer work that is not needed yet, and load non-essential code later, as the INP fixes in the Core Web Vitals guide recommend.

Verify: the trace around the slow interaction shows short tasks and a small input delay on the throttled profile.

Prevent: flag long tasks in the lab checks that run on each release, so a new script that monopolises the thread is caught before it ships.

A handler that does everything before drawing anything

Some handlers do far more than the visitor needs to see: recalculating a whole product list on a filter tap, validating every field on each keystroke, or sending analytics synchronously before updating the button. The visitor waits for all of it.

Fix: update the visible state first, such as the pressed button, the opened menu or a loading indicator, then schedule the rest; keep handlers light and move heavy computation off the main thread where possible, following the Core Web Vitals guide. Debounce input handlers that run on every keystroke.

Verify: the processing part of the interaction shrinks in the trace, and the visual feedback appears in the next frame.

Prevent: review new handlers for what they do before the first paint, and make "feedback first" a code review question.

Scripts the business added, not the developers

Tag manager containers, chat widgets, session recording, testing tools and advert scripts all execute on the same main thread as the site. Each is small; together they keep it busy, and many of them listen to clicks and run code on every interaction. The Tag Manager container (GTM) is often where they accumulate. A recording tool added for conversion research is no exception, which is why the tutorial on reviewing session recordings and heatmaps checks the script's cost before any recordings are collected.

Fix: inventory every third-party script with an owner and purpose, remove the ones nobody can justify, and load the rest on idle or after the visitor interacts, using the performance budget and change control in the tag governance guide.

Verify: the share of long tasks attributed to third-party domains falls in the trace, and input delay on the slow interaction drops.

Prevent: require every new tag to pass the performance budget before it is published, and audit the container on a fixed schedule.

Each interaction triggers a large redraw

When an interaction changes something that forces the browser to recalculate styles and layout for much of the page, the time lands after the handler, in presentation delay. Toggling a class high in the document, reading layout values straight after writing them, and re-rendering long lists are typical sources.

Fix: confine updates to the smallest part of the page, avoid reading layout immediately after changing it, keep the document from growing unnecessarily large, and render long lists in windows, using the rendering advice in the Core Web Vitals guide.

Verify: style and layout entries after the handler shrink, and presentation delay becomes a small part of the interaction.

Prevent: test interactions on the largest realistic pages, such as a category with its full product count, not on a sparse example.

Hydration holding up the first taps

Framework sites that render on the server and then hydrate in the browser can look ready before they are. Early taps land while the framework is still evaluating scripts and attaching handlers, so they wait or are lost. Later interactions are fine, which is why the problem hides in quick tests.

Fix: ship less script to the page, hydrate components selectively or progressively so the interactive parts that matter become ready first, and render static content without client-side code, as the hydration section of the JavaScript SEO guide explains.

Verify: a recording that taps the main control as soon as it appears shows a quick response, and the start-up tasks shorten.

Prevent: set a script budget per template and track the size of what each page hydrates.

Prevention: a script budget and tag governance

Responsiveness erodes one addition at a time, so the defence is a budget everybody shares. Agree, per template, how much script the page may run in its first moments and how long any task may hold the main thread, then measure both in the lab checks on every release, on a throttled phone profile. Count third-party code against the same budget as the site's own; the tag governance guide gives the inventory, owner and approval routine that makes that possible for tags added outside the release process.

Alongside the budget, keep an interaction test list for each template: the handful of interactions visitors actually perform, recorded on each release and compared with the last run. Monthly, read the Core Web Vitals report by URL group and investigate any group that changes status. Google's page on Core Web Vitals presents them as part of page experience within SEO, so the work supports search without replacing relevance; the immediate gain is a site that answers when people press things. If the same group also fails visual stability or loading, the sibling pages on layout shift and slow largest contentful paint cover those metrics on their own.

Illustrative example — not a real result

An outdoor retailer's filter taps on mobile

An outdoor retailer's mobile category template sits in a "poor" INP group of 1,450 URLs, with field INP around 480 milliseconds. Recording a filter tap on a throttled phone shows an input delay of 160 milliseconds, processing of 230 milliseconds and presentation of 90 milliseconds. The input delay comes from a session recording script running long tasks; the processing comes from a handler that rebuilds all 120 product cards and sends an analytics event before updating the button. The team delays the recording script until after the first interaction, changes the handler to update the button and a loading state first, and re-renders only the cards that change. The recorded tap falls to about 150 milliseconds, and over the next six weeks the field group moves to "good".

Common mistakes

Optimising load speed when the slow part is an interaction. Testing on a desktop processor. Blaming the handler when the input delay is caused by an unrelated script. Adding tags without a budget. Checking only the first interaction after load. Other Search Console symptoms are routed from the SEO troubleshooting hub.

Frequently asked questions

Which interaction is the slow one, when Search Console only names a URL group?

The report does not name it, so it has to be found. Interact with an example page the way visitors do, on a throttled phone profile, while recording in the performance panel, and look for the interactions with the longest delay before the next frame. Menus, filters, add-to-basket buttons, accordions and form fields are the usual suspects; real-user monitoring that reports the interaction target narrows it further.

Why does my fast laptop never reproduce the problem?

Field data comes from real visitors, many of them on mid-range phones where the same script takes several times longer to run. A task that is unnoticeable on a desktop can block the main thread on a phone. Throttle the processor in the browser's performance panel to approximate those devices before deciding there is nothing to fix.

Is INP mostly a developer problem or a marketing problem?

Both. The site's own code decides how heavy each event handler is, but tags added through a tag manager, chat widgets, testing tools and advert scripts are, on many sites, a large share of what keeps the main thread busy. Responsiveness improves fastest when engineering and the team that adds tags share one budget for main-thread work.

Terms used on this page

Where this page is used

Also related

Sources

  1. Understanding Core Web Vitals and Google search results — Google Search Central
  2. Web Vitals — web.dev
  3. Core Web Vitals report — Google Search Console Help

Related