Get a free consultation
Website Design

FID Is Gone, INP Is the Metric: How to Fix Slow Interactions

By Sigmato Editorial TeamUpdated 15 Nov 20266 min read

Close-up of hands holding a smartphone outdoors during the day.

Key takeaways

  • Interaction to Next Paint (INP) replaced First Input Delay (FID) as a Core Web Vital on 12 March 2024.
  • FID only measured the delay before the first interaction began. INP looks at every click, tap and key press during a visit.
  • A good INP is 200 milliseconds or less at the 75th percentile of real visits. Above 500 ms is poor.
  • Every interaction has three parts: input delay, processing time and presentation delay. Each has a different fix.
  • Start with field data. Lab tools can reproduce a problem but cannot tell you which interactions your visitors actually find slow.
Close-up of hands holding a smartphone outdoors during the day.

What happened to FID?

For years, First Input Delay was the Core Web Vital for responsiveness. It had a flaw that everyone in performance work knew about: it measured only the time between a visitor’s first interaction and the moment the browser could start handling it. It ignored how long the work took and ignored every later interaction. A page could post an excellent FID and still feel sluggish every time you opened a menu or filled in a form.

Google replaced it. INP became a stable Core Web Vital in March 2024, and FID stopped being part of the set. If your reports, dashboards or contracts still mention FID, they are measuring a retired metric.

FID vs INP at a glance

FID (retired) INP (current)
What it looks at Only the first interaction All clicks, taps and key presses across the visit
What part of the delay Only the wait before handling started The whole journey: wait, handler work and the next painted frame
What gets reported One value per page load The slowest interaction (ignoring one highest per 50 interactions)
Good threshold 100 ms 200 ms or less

INP counts mouse clicks, screen taps and key presses. It does not count scrolling, hovering or zooming. It is reported at the 75th percentile of page loads, split between mobile and desktop, so a quarter of your visits can be worse than your reported number.

The INP thresholds

Rating INP at the 75th percentile
Good 200 ms or less
Needs improvement Over 200 ms and up to 500 ms
Poor Over 500 ms

The three parts of every interaction

When a visitor taps a button, three things happen before they see a response. INP is the sum, so you fix the part that is largest on your page.

  1. Input delay. The browser is busy with something else (usually a long task on the main thread) and cannot start your handler yet.
  2. Processing duration. Your event handlers run. If they do a lot of work, the visitor waits.
  3. Presentation delay. After the handlers finish, the browser still has to work out styles and layout and paint the next frame. A large or complicated page makes this slower.

How to find the slow interactions

Follow this order. It saves hours of guessing.

  1. Look at field data. Use the Core Web Vitals report in Search Console and the real-user section of PageSpeed Insights. This tells you whether you have a problem at all and on which URLs.
  2. Collect attribution from real visitors. Google’s open-source web-vitals library can report which element and which phase was slow:
import { onINP } from 'web-vitals/attribution';

onINP((metric) => {
  // Send this to your analytics endpoint
  console.log(metric.value, metric.attribution.interactionTarget,
              metric.attribution.inputDelay,
              metric.attribution.processingDuration,
              metric.attribution.presentationDelay);
});
  1. Reproduce it in the lab. Open Chrome DevTools, record a performance trace, and repeat the interaction on a throttled CPU. Try interactions during page load, when the main thread is usually busiest.
  2. Check which frame it happens in. Each iframe has its own main thread, and a chat widget or embedded form can be the culprit.

Fixing input delay

The page is too busy to listen. The usual cause is JavaScript doing a lot of work at startup or in the background.

  • Reduce the amount of script that runs during load: remove unused libraries, split bundles and load non-essential code later.
  • Audit third-party scripts. Tag managers, chat widgets, A/B testing tools and ad scripts often do more main-thread work than your own code.
  • Break up long tasks so the browser can respond between pieces. See Google’s guide to optimising long tasks.

Fixing processing duration

Your handler does too much before it lets the browser paint. The rule is: do the minimum visible thing first, then defer everything else.

// A small helper that lets the browser paint and respond to input
function yieldToMain() {
  if (window.scheduler && scheduler.yield) {
    return scheduler.yield();
  }
  return new Promise((resolve) => setTimeout(resolve, 0));
}

button.addEventListener('click', async () => {
  showSpinner();            // 1. update the screen first
  await yieldToMain();      // 2. let the browser paint
  await saveToServer();     // 3. do the heavy work after
  trackEvent('saved');      // 4. non-urgent work last
});
  • Avoid layout thrashing: do not read layout values (such as an element’s size) straight after changing styles in the same task, because that forces the browser to recalculate.
  • Keep event handlers short and move analytics, logging and non-visual work out of the click path.
  • Debounce handlers on fast events such as typing in a search box.

Fixing presentation delay

The code finished, but drawing the next frame is still slow. This is usually about how much page the browser has to manage.

  • Keep the DOM small. Large, deeply nested pages make every style and layout calculation more expensive. Page builders and heavy themes are common sources of unnecessary nesting.
  • Use content-visibility to skip rendering work for sections that are off-screen:
.long-section {
  content-visibility: auto;
  contain-intrinsic-size: auto 800px;
}
  • Avoid building huge amounts of HTML in the browser with JavaScript after every interaction. Render on the server where you can.

Common INP offenders on business websites

Culprit What to try
Chat and support widgets Load on first interaction or after idle, not on page load
Tag managers with many tags Remove dead tags, load the rest later, review quarterly
Mega menus and carousels Use lightweight CSS and small scripts; avoid autoplay sliders
Cookie and consent banners Keep the script small and render it without blocking the page
Form validation and scripts Validate lightly and avoid re-rendering the whole form on every key press
Deeply nested page builder layouts Simplify sections and reduce wrappers; consider a lean template for key pages
Old jQuery plugins Replace with small native scripts where practical

A simple monthly routine

  1. Check the Core Web Vitals report in Search Console for INP groups marked “needs improvement” or “poor”.
  2. Open one URL from each group and find the slowest interaction.
  3. Fix the largest of the three phases first.
  4. Re-check after the next 28 days of field data, because the reported figure is based on a rolling window of real visits.

Do not chase a perfect score. Google’s own guidance on page experience says good scores do not guarantee top rankings and that there is more to a great experience than the numbers. Aim for “good”, then spend the time on content and usability. For the wider picture, our guide to Core Web Vitals and our notes on WordPress speed optimisation are good next steps, and if you would like us to audit your site, you can contact our team.

Frequently asked questions

When did INP replace FID?

INP became a stable Core Web Vital and replaced First Input Delay on 12 March 2024. FID is no longer one of the three Core Web Vitals.

What is a good INP score?

200 milliseconds or less at the 75th percentile of real page loads. Between 200 and 500 ms needs improvement, and above 500 ms is poor.

Does INP count scrolling?

No. INP counts clicks, taps and key presses. Scrolling, hovering and zooming are not counted, although a gesture that includes a click or tap can be.

Can I measure INP with Lighthouse?

Lighthouse gives a lab view and can help you reproduce slow interactions, but INP is a field metric. Use real-user data from Search Console, PageSpeed Insights or the web-vitals library.

What is the quickest way to improve INP?

Find which phase is slowest. Often the fastest wins are removing or delaying third-party scripts, shortening click handlers so the browser can paint first, and reducing page size and nesting.

Is INP a ranking factor?

Core Web Vitals are used by Google’s ranking systems, but Google says good scores do not guarantee top rankings. Treat INP as a user experience goal, not a trick.

Sources and further reading

Sigmato Editorial Team

Written by

Sigmato Editorial Team

The Sigmato Editorial Team is made up of software engineers, UI/UX designers and AI specialists at Sigmato Solutions Pvt Ltd in Bengaluru, India and the UK. We write practical guides on web, mobile, cloud and AI development, drawing on the products we design and build for startups and enterprises worldwide.

Last updated 15 November 2026 · Talk to our team