Home Website PerformanceHow to Fix INP and Improve Website Responsiveness

How to Fix INP and Improve Website Responsiveness

by Iffaris
6 views 21 minutes read
Fix INP to improve website responsiveness and Core Web Vitals performance

You tap a menu button and nothing happens. You tap again, and suddenly the menu opens, closes and opens once more. Visitors do not stay patient in moments like that. They assume the site is broken and leave. If this sounds familiar, you need to fix INP, the Core Web Vitals metric that measures exactly how fast your pages respond to real user actions.

Interaction to Next Paint, or INP, is one of the most misunderstood performance metrics, and one of the hardest to improve because the causes sit deep inside JavaScript. This guide explains what INP measures, how to find the interactions that drag your score down, and how to fix INP with twelve practical techniques. It also covers WordPress-specific fixes, since most small business sites run on WordPress with page builders, sliders and third-party widgets that quietly pile up work on the browser.

You do not need to be a senior engineer to follow along, and anyone can learn how to fix INP with the right process. If you can read a performance report and work with a developer or a plugin settings panel, you can make real progress. Let us start with the basics.

What Is INP and Why Does It Matter?

INP stands for Interaction to Next Paint. It measures the time between a user interaction, such as a click, a tap or a key press, and the moment the browser paints the next frame showing the result of that interaction. Google replaced First Input Delay with INP as a Core Web Vital in March 2024, because First Input Delay only measured the delay before the very first interaction. INP looks at every interaction during a visit and reports a value that reflects the slowest ones.

That difference is important. A page can feel quick on the first click and sluggish afterwards because scripts keep loading, ads keep running and the browser stays busy. INP exposes that problem. When you set out to fix INP, you are not chasing a single early delay. You are making the whole page feel responsive from the first second to the last.

INP Thresholds You Need to Know

Google groups INP results into three bands, based on the 75th percentile of real page visits:

  • Good: 200 milliseconds or less
  • Needs improvement: between 200 and 500 milliseconds
  • Poor: more than 500 milliseconds

The 75th percentile means that three out of four visits must meet the threshold for your page to pass. Mobile and desktop are assessed separately, and mobile is usually the harder one because phones have slower processors. If your goal is to fix INP across your site, plan to test on mid-range phones rather than a fast laptop.

Why a Slow INP Hurts Your Business

Responsiveness affects revenue as well as rankings. Core Web Vitals are a confirmed part of Google’s page experience signals, so a poor result will not help your search performance. It is a tiebreaker rather than a magic switch, but in competitive local markets, tiebreakers decide who appears in the top results. More directly, slow interactions cause abandoned forms, missed phone-call clicks and failed bookings. For a service business, a sluggish “Call Now” button is lost money. To fix INP where it matters commercially, start with the buttons that bring in calls.

If you want to see how responsiveness fits into the bigger picture, our partner site explains Core Web Vitals in plain language, including how field data and lab data differ.

How INP Is Measured: The Three Phases of an Interaction

To fix INP properly, you need to understand what happens during an interaction. Every interaction passes through three phases, and a delay in any of them increases your score.

1. Input delay. This is the time between the user’s action and the moment the browser can start running your event handlers. If the main thread is busy with another task, such as a large script executing, the browser must wait. Long tasks and heavy third-party scripts are the usual culprits.

2. Processing time. This is how long your event handlers take to run. A click handler that performs heavy calculations, updates many elements or triggers several scripts adds directly to this phase.

3. Presentation delay. After the handlers finish, the browser must recalculate styles, perform layout and paint the new frame. Large DOM trees, complex CSS and expensive rendering work stretch this phase.

Each technique that helps you fix INP in this guide targets one or more of these phases. When you diagnose a slow interaction, always ask which phase is responsible, because the right fix depends on the answer.

How to Check Your INP Score

Before you try to fix INP, you need reliable data. There are two kinds, and both are useful.

Field Data: What Real Users Experience

Field data comes from real visitors using real devices, so always begin with it when you fix INP. It is the data Google uses for ranking signals. You can find it in:

  • PageSpeed Insights, which shows Chrome User Experience Report data for your URL and your origin when enough traffic exists
  • The Core Web Vitals report in Google Search Console, which groups URLs by status and highlights pages that need work
  • Real user monitoring tools, including the free web-vitals JavaScript library, which you can wire into Google Analytics

If you are new to Search Console, start with our guide to the Google Search Console performance report to learn how to read the data and spot problem pages.

Lab Data: Reproducing the Problem

Lab tools let you reproduce a slow interaction on demand. Lighthouse does not measure INP directly because it does not perform real interactions in a standard load test, but it reports Total Blocking Time, which correlates well with responsiveness problems. For true interaction testing, use the Performance panel in Chrome DevTools, where you can click through a page and see exactly which tasks block the main thread. Chrome also offers an interaction timeline that highlights slow interactions as you test.

A good routine to fix INP is to find a failing page in field data, then reproduce the slow interaction in DevTools with CPU throttling enabled. If you also want to benchmark general load speed, our website speed test guide explains how to run and interpret common tools.

Common Causes of Poor INP

Before you fix INP, here are the patterns that cause most failing scores:

  • Long JavaScript tasks that block the main thread for more than 50 milliseconds
  • Heavy third-party scripts such as chat widgets, tracking pixels, A/B testing tools and ad networks
  • Large DOM sizes with thousands of elements
  • Poorly written event handlers that do too much work on every click or keystroke
  • Layout thrashing, where scripts repeatedly read and write layout properties
  • Bloated page builders, sliders, animation libraries and unused plugins
  • Heavy framework hydration on pages built with modern JavaScript frameworks

You will probably find more than one cause on a failing page. The twelve steps to fix INP below work through them in a logical order, starting with measurement and ending with architectural improvements.

12 Ways to Fix INP

1. Identify the Slowest Interactions First

The fastest way to waste time is to optimise things that were never slow. Start by finding which interactions fail. In Chrome DevTools, open the Performance panel, start recording, perform the interaction that feels slow, and stop. Look at the interaction track to see how long each action took and which phase caused the delay.

Pay attention to the common offenders: opening a mobile menu, expanding an accordion, adding to cart, submitting a form, filtering a list and typing into a search box. Write down the three slowest interactions on each template, because fixing the worst few usually moves your score the most. This diagnostic habit is the foundation of any effort to fix INP.

2. Break Up Long Tasks

The browser’s main thread handles scripts, layout and user input one task at a time. Any task running longer than 50 milliseconds is considered a long task, and while it runs, the browser cannot respond to a tap. Long tasks are the single biggest reason sites fail INP.

To fix INP caused by long tasks, split the work into smaller chunks so that the browser can handle user input between them. Instead of running a loop that processes ten thousand items in one go, process a few hundred at a time and let the browser breathe before continuing. In DevTools, long tasks appear with a red corner marker, which makes them easy to spot.

3. Yield to the Main Thread

Yielding means pausing your script so the browser can handle pending input and rendering, and it is the core technique used to fix INP on JavaScript-heavy pages. Modern browsers offer scheduler.yield(), which resumes your work with higher priority than a standard timer. Where it is not supported, a simple setTimeout with zero delay works as a fallback.

A common pattern is to run only the work needed to show visual feedback immediately, then yield, and finish the less urgent work afterwards. For example, when a user clicks “Add to Cart,” update the button state first, yield, and then send analytics events and refresh secondary widgets. The user sees an instant response, and your INP drops because the next paint happens sooner.

4. Reduce and Defer JavaScript

Every kilobyte of JavaScript must be downloaded, parsed, compiled and executed, and that work competes with user interactions. To fix INP at the root, ship less code:

  • Remove scripts the page does not need
  • Load non-critical scripts with defer or async
  • Code-split large bundles so each page loads only what it uses
  • Use the Coverage tool in DevTools to find unused JavaScript
  • Delay scripts that are not needed until the user interacts, such as chat widgets

Page builders and multipurpose themes often load their entire JavaScript library on every page, even when a page uses one small feature. Trimming that load can cut input delay dramatically on mobile devices. For more ideas on trimming code and assets, see our guide on WordPress website speed.

5. Tame Third-Party Scripts

Third-party code is one of the most common reasons a site cannot fix INP, because you do not control it. Tag managers, heatmaps, live chat, social embeds, review widgets and advertising scripts all share the same main thread as your own code.

Audit every third-party script and ask whether it earns its place. Remove tools nobody uses, replace heavy widgets with lighter alternatives, and load the remaining ones after the page is interactive. Where possible, self-host fonts and small libraries to avoid extra connections. If a script must stay, consider loading it on user interaction or after a short delay, and consider moving heavy work into a web worker so it runs off the main thread.

Test the effect with and without each script. You may be surprised how much a single chat widget costs on a mid-range phone. Cutting third-party weight is often the quickest way to fix INP on a marketing site.

6. Optimise Your Event Handlers

Event handlers should be small and fast. Common problems include running expensive calculations inside a click handler, attaching listeners to hundreds of individual elements, and firing handlers on every scroll or keystroke event.

Practical improvements include:

  • Use event delegation, attaching one listener to a parent instead of many to children
  • Debounce or throttle handlers for typing, resizing and scrolling
  • Use passive listeners for scroll and touch events where appropriate
  • Move heavy computation out of the handler and run it after the visual update

When you fix INP in a handler, the goal is not to remove functionality. It is to ensure that the first visual response happens quickly and everything else follows.

7. Give Immediate Visual Feedback

INP measures the time until the next paint, not until all work finishes. That means you can improve the metric, and the real experience, by showing something right away. Change a button to a loading state, open a menu container, or display a spinner before starting slower work.

This is not a trick. Users feel responsiveness when the interface acknowledges their action quickly, even if a background process continues for a moment. Instant feedback is one of the cheapest ways to fix INP without rewriting backend logic. Designers should plan these feedback states from the start, and our article on homepage design shows how clear above-the-fold elements support usability as well as conversions.

8. Reduce DOM Size

A large DOM makes every style recalculation, layout and paint slower, which inflates the presentation delay phase. Lighthouse starts warning when a page has roughly 800 nodes or more and treats very large DOMs as a serious problem. Pages built with nested page-builder sections often contain thousands of elements for a modest amount of content.

To trim the DOM:

  • Remove unnecessary wrapper elements and empty containers
  • Avoid rendering huge lists all at once; paginate or load items as the user scrolls
  • Simplify mega menus and hidden content that load with every page
  • Replace complex widgets with simpler, native HTML where possible

This is one of the most reliable ways to fix INP on content-heavy pages, because every future interaction becomes cheaper.

9. Avoid Layout Thrashing and Expensive Style Recalculation

Layout thrashing happens when a script alternates between reading layout values, such as an element’s height, and writing styles, forcing the browser to recalculate layout repeatedly within a single task. Group reads together, then group writes, or use requestAnimationFrame to schedule visual changes. Cleaning up layout work is another practical way to fix INP on interactive pages.

Also avoid changing styles that affect the entire page, such as toggling a class on the body element, when only a small component needs to change. Narrower selectors and scoped changes limit how much the browser must recalculate. Prefer animating transform and opacity rather than properties like width and height, which trigger layout.

10. Use CSS Containment and content-visibility

The CSS property content-visibility: auto lets the browser skip rendering work for off-screen sections until they are about to appear. Combined with contain-intrinsic-size, which reserves space to prevent layout shifts, it can reduce rendering cost on long pages with many sections.

CSS containment tells the browser that a component’s internals do not affect the rest of the page, so changes inside it do not trigger a full-page layout. These properties are well supported in modern browsers, but test carefully. Used incorrectly, they can cause jumpy scrolling or hide content from in-page search. Applied thoughtfully, they help you fix INP on pages that contain long lists, reviews, galleries or service listings.

11. Optimise Framework Hydration and Rendering

If your site uses a JavaScript framework, interactions may be slow because the browser is still hydrating components or re-rendering large trees on every state change. Consider these approaches:

  • Render as much as possible on the server and send less JavaScript to the client
  • Use partial or selective hydration so only interactive components load their code
  • Memoize expensive components so they do not re-render unnecessarily
  • Mark non-urgent updates as low priority so urgent input is handled first
  • Virtualize long lists so only visible rows are rendered

Many small business sites do not use these frameworks, but if yours does, hydration cost is often the hidden reason you cannot fix INP despite a fast server.

12. Move Heavy Work Off the Main Thread

Web workers run JavaScript on a separate thread, so heavy calculations, data processing and some third-party scripts can execute without freezing the interface. Workers cannot touch the DOM directly, so they suit pure computation rather than visual updates. Several tools can relocate third-party scripts into workers automatically, which can be a practical option when you cannot remove a tag but need it to stop blocking interactions.

This is an advanced technique, and it usually comes after the simpler fixes. If you have already reduced scripts, split long tasks and trimmed the DOM, a worker may handle the remaining heavy lifting. A worker is rarely the first tool you reach for to fix INP, but it is a powerful last resort.

How to Fix INP on WordPress Websites

WordPress sites are especially prone to responsiveness problems because they depend on plugins, themes and page builders that each add scripts. The good news is that WordPress also offers straightforward ways to fix INP without writing code.

Audit Your Plugins

Every active plugin can add JavaScript to your front end. Deactivate plugins one at a time on a staging site and measure the difference. Remove anything redundant, such as three plugins that all add sliders or popups, and replace heavy plugins with lighter ones. Our guide on how to choose the right WordPress plugins offers a simple vetting process. A plugin audit is the first practical step to fix INP on most WordPress sites.

Choose a Lightweight Theme and Build Carefully

Multipurpose themes load large script bundles by design. A lean theme with a restrained page builder setup produces smaller DOMs and fewer scripts. If you rely on a page builder, avoid deep nesting, reduce the number of widgets per page and disable features you do not use. Choosing the right foundation makes it easier to fix INP and keep it fixed.

Use Script Management Tools Carefully

Optimisation plugins can delay JavaScript execution until the first user interaction, defer non-critical scripts and remove unused assets on specific pages. They can make a big difference, but aggressive settings can also break menus, forms and sliders. Change one setting at a time, test on mobile and always keep a recent backup. Used carefully, these tools help you fix INP quickly, but only when each setting is tested.

Watch Common WordPress Offenders

When you try to fix INP on WordPress, check these usual suspects first: sliders and carousels, mega menus, live chat widgets, cookie banners, popups, social feed embeds, WooCommerce cart fragment scripts, analytics and tag manager containers, and review widgets. Many of these can be replaced by lighter versions or loaded only on the pages that need them.

Keep WordPress Maintained

Outdated plugins and themes often contain inefficient code, and updates frequently include performance improvements. A regular routine keeps responsiveness from drifting back to poor. Follow our WordPress maintenance checklist to build a monthly habit that covers updates, backups and performance checks.

Fix INP for Local Business and Service Websites

If you run a site for an electrician, plumber, appliance repair company or towing service, most of your visitors arrive on mobile devices, often in a hurry. They want to tap a phone number, open a booking form or read a service page. Every second of delay increases the chance they will call a competitor instead.

For these sites, prioritise the interactions that create revenue:

  • The tap-to-call button in the header and sticky mobile bar
  • Quote and booking forms, including field validation
  • Mobile menu opening and closing
  • Image galleries and before-and-after sliders
  • Review widgets and service-area maps

A service page does not need heavy animation or a dozen tracking scripts. Keep it simple, fast and focused on the action you want the visitor to take. Our partner site shares practical advice on how to improve website speed for small business owners, and its article on why your website is slow helps you diagnose common problems quickly. If you want to understand how speed connects to rankings, read about website speed and SEO as well.

How to Test and Monitor After You Fix INP

Fixing a problem once is not enough, because new scripts and content changes can bring it back. Build a simple monitoring routine.

Test every change. After each fix, repeat the same interaction in DevTools with CPU throttling and confirm the improvement. Measure before and after so you can prove that you managed to fix INP rather than guessing. Avoid making many changes at once, because you will not know which one worked.

Watch field data over time. Field data in Search Console and PageSpeed Insights updates on a rolling 28-day window, so improvements take weeks to appear fully. Do not panic if the report still shows red a few days after your fix. Check whether the lab results improved, then wait for the field data to catch up.

Track by template. Group your pages by type, such as home, service, blog and contact. If one template fails, fixing it will often fix hundreds of URLs at once.

Set up alerts. Use real user monitoring or scheduled tests so you hear about regressions soon after a new plugin, tag or design change goes live.

Responsiveness is also part of a larger technical health routine. Our technical SEO checklist shows how performance connects with crawling, indexing and site structure, and our guide to Google Analytics 4 website traffic explains how to see whether faster interactions improve engagement and conversions.

Common Mistakes When Trying to Fix INP

Many site owners spend weeks trying to fix INP with changes that barely help. Avoid these mistakes:

Relying only on lab scores. A perfect Lighthouse score does not guarantee good INP, because Lighthouse does not run real interactions in the same way. Always check field data.

Testing only on a fast desktop. Your laptop hides problems that appear on a mid-range phone. Use CPU throttling and real devices.

Piling on optimisation plugins. Stacking several caching and script-delay tools can create conflicts and new delays. Use one well-configured solution.

Ignoring third-party scripts. You can optimise your own code perfectly and still fail because of one slow widget. Audit every external script.

Chasing the average instead of the worst case. INP reflects the slowest interactions, so improving easy interactions will not change the score if one heavy interaction remains. Find and fix the worst case.

Forgetting to retest. A fix that worked in January may be undone by a new plugin in March. Make testing part of your routine.

Quick Checklist to Fix INP

Use this list as a working summary when you set out to fix INP on a page:

  • Check field data in Search Console and PageSpeed Insights
  • Reproduce the slow interaction in Chrome DevTools with throttling
  • Identify whether the delay is input delay, processing time or presentation delay
  • Break up tasks longer than 50 milliseconds
  • Yield to the main thread between chunks of work
  • Remove, defer or replace heavy third-party scripts
  • Simplify event handlers and show instant visual feedback
  • Reduce DOM size and avoid layout thrashing
  • Use content-visibility on long, below-the-fold sections
  • Audit plugins, sliders and page builder widgets on WordPress
  • Retest, then monitor field data for at least 28 days

Final Thoughts

Responsiveness is no longer optional. As Google rewards sites that feel fast to use, not only fast to load, the businesses that fix INP gain a real advantage in both search visibility and customer experience. The process is straightforward even if the details are technical: measure real data, find the slowest interactions, identify which phase is responsible, and apply the right fix.

Start with the biggest wins. Remove scripts you do not need, break up long tasks, simplify the page structure and show instant feedback when users act. Then monitor your field data and repeat the cycle whenever you add new features. If you commit to this routine, you will fix INP once and keep it fixed, instead of fighting the same problem every few months. The sooner you fix INP, the sooner you stop losing visitors to slow interactions.

Frequently Asked Questions About How to Fix INP

What is a good INP score?

A good INP score is 200 milliseconds or less at the 75th percentile of page visits. Scores between 200 and 500 milliseconds need improvement, and anything above 500 milliseconds is considered poor. Aim for under 200 on both mobile and desktop, because reaching that target is the goal whenever you fix INP.

How long does it take to fix INP?

Simple fixes such as removing an unused plugin or deferring a script can be done in an afternoon. More complex problems, such as heavy framework hydration, may take weeks. Remember that field data uses a rolling 28-day window, so it takes about a month to see the full effect of your changes in reports.

Can I fix INP without a developer?

Often yes, you can fix INP without a developer, especially on WordPress. You can remove unused plugins, replace heavy widgets, delay non-critical scripts with an optimisation plugin and simplify your page builder layouts. Deeper fixes that involve rewriting event handlers or splitting long tasks usually need a developer.

What is the difference between INP and FID?

First Input Delay measured only the delay before the browser began handling the first interaction. INP measures the full latency of interactions throughout the visit, including processing and rendering time. That makes it a stricter and more realistic measure of responsiveness, which is why you must fix INP differently than you once handled FID.

Does INP affect SEO rankings?

INP is part of Core Web Vitals, which feed into Google’s page experience signals. Good scores will not outrank great content on their own, but they help, especially when competing pages are similar in relevance. The user experience benefits, including fewer abandoned forms and more completed bookings, are valuable even beyond rankings.

Why is my INP poor on mobile but good on desktop?

Phones have slower processors and less memory, so the same JavaScript takes much longer to run. A script that costs 40 milliseconds on a laptop can cost 200 milliseconds or more on a mid-range phone. To fix INP on mobile, reduce JavaScript, trim the DOM and test with CPU throttling.

Related Posts

Leave a Comment

Focus Mode