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

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.

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.
- Input delay. The browser is busy with something else (usually a long task on the main thread) and cannot start your handler yet.
- Processing duration. Your event handlers run. If they do a lot of work, the visitor waits.
- 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.
- 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.
- 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);
});
- 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.
- 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-visibilityto 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
- Check the Core Web Vitals report in Search Console for INP groups marked “needs improvement” or “poor”.
- Open one URL from each group and find the slowest interaction.
- Fix the largest of the three phases first.
- 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.