INP vs FID: Why Google Replaced First Input Delay (2024)
INP vs FID: INP replaced FID as a Core Web Vital in March 2024. See what each measures, why FID missed slow interactions, and what to change in your monitoring.
Kazi Khalid Hasan Tamim · BugViso Team
12 min read
INP vs FID: INP (Interaction to Next Paint) replaced FID (First Input Delay) as a Core Web Vital on March 12, 2024.
FID timed only the delay before the browser began handling a page's first interaction. INP measures the full latency of every click, tap and keypress, from input to the next painted frame, and reports a near-worst value.
The change matters because FID was easy to pass: it ignored processing time, presentation time and every interaction after the first. Sites that passed FID could still feel sluggish, and INP exposes that.
The three metrics are defined in what LCP, INP and CLS measure.
This guide explains the technical mechanics of both metrics, why FID's design was structurally flawed, exactly what INP measures differently, and what you need to change in your performance monitoring stack.
For the full real-user setup, see INP monitoring with real users, and for what slows interactions down, see common causes of poor INP.
What FID Measured (And Why It Was Blind to Real Problems)
First Input Delay measured one specific thing: the time between a user's first discrete input event (click, tap, or keypress) and the moment the browser's main thread became available to begin processing that event's handler.
FID covered only the first slice of an interaction: from the user's click until the event handler started. INP covers the whole span, from the click, through the handler's processing time, to the next painted frame.
FID did not measure processing or presentation time at all.
FID's Three Structural Flaws
Flaw 1: FID only measured the first interaction.
A user who lands on a page while the main thread is idle (common: most pages complete JS execution before the first click) would register a very low FID.
But their second, third, and tenth interactions — selecting product variants, opening dropdown menus, typing in search boxes — might each be slow. FID would never capture these.
Flaw 2: FID only measured the input delay phase.
The total time a user waits after clicking a button has three components:
| Phase | What Happens | Measured by FID? | Measured by INP? |
|---|---|---|---|
| Input Delay | Main thread is busy; user input waits in queue | ✅ Yes | ✅ Yes |
| Processing Time | Event handler executes (your onClick code runs) | ❌ No | ✅ Yes |
| Presentation Delay | Browser recalculates layout, paints, composites the next frame | ❌ No | ✅ Yes |
A button click with 5ms input delay (FID: 5ms, "Good") but 400ms processing time and 100ms presentation delay would feel completely unresponsive to the user — yet FID would report it as perfect.
Flaw 3: FID could only be measured in the field.
FID required real user interaction, so it could only be captured via Real User Monitoring (RUM) or the Chrome UX Report.
Lab tools like Lighthouse couldn't measure it. They used Total Blocking Time (TBT) as a proxy, creating confusion between lab and field metrics.
💡 Engineering Rule of Thumb: FID asked "how long did the first click wait to start processing?" INP asks "how long did the user wait from click to seeing the result, on every interaction?" The difference is between measuring the queue time at a restaurant versus measuring the total time from ordering to receiving your food.
INP vs FID: What INP Measures Differently
Interaction to Next Paint captures the complete user-perceived latency for every discrete interaction during the entire page session, then reports the worst (p98) interaction as the page's INP score.
For a step-by-step method that finds which phase is slow and fixes it, see what INP is and how to fix it phase by phase.
// The three phases INP measures for every interaction
interface InteractionTiming {
// Phase 1: Input Delay
// Time between user input and handler execution start
inputDelay: number // Main thread was busy with other work
// Phase 2: Processing Time
// Time to execute all event handlers for this interaction
processingTime: number // Your onClick/onChange/onKeyDown code
// Phase 3: Presentation Delay
// Time between handler completion and next frame paint
presentationDelay: number // Style recalc + layout + paint + composite
// Total INP = inputDelay + processingTime + presentationDelay
total: number
}INP Scoring Thresholds
| INP Score | Rating | User Perception |
|---|---|---|
| ≤ 200ms | 🟢 Good | Interaction feels instant |
| 201–500ms | 🟡 Needs Improvement | Noticeable delay, user may retry |
| > 500ms | 🔴 Poor | Interaction feels broken |
How INP Selects the Reported Value
INP doesn't report the single worst interaction. It reports the 98th percentile (approximate) interaction.
For a page session with 50+ interactions, this is the second-worst interaction. For sessions with fewer interactions, it's the worst.
Example session with 20 interactions:
Interaction 1: 45ms ✅ Good
Interaction 2: 62ms ✅ Good
Interaction 3: 312ms 🔴 Poor (expanding accordion with heavy re-render)
Interaction 4: 78ms ✅ Good
...
Interaction 19: 55ms ✅ Good
Interaction 20: 198ms ✅ Good
Reported INP: 312ms (worst interaction = p98 for <50 interactions)
Under FID: 45ms (only first interaction counted → declared "Good")
Under INP: 312ms (worst interaction counted → declared "Poor")Why Sites That Passed FID Can Fail INP
FID looked at one thing: how long the first interaction waited before its handler started. INP adds the handler's own run time and the time to paint the result, across the whole visit.
Three site types are hit hardest:
- Single-page apps and React/Vue/Angular dashboards, where re-rendering and state updates make every interaction expensive, a cost FID never captured.
- E-commerce pages with filters, carts and third-party widgets competing for the main thread.
- Media-heavy or interactive pages that keep the main thread busy after load.
Migrating Your Monitoring: FID → INP
Migrating from FID to INP means updating the web-vitals library, your performance budgets, and your dashboards and alerts.
Step 1: Update Your web-vitals Library
// ❌ Old: FID monitoring (deprecated)
import { onFID } from 'web-vitals'
onFID((metric) => {
console.log('FID:', metric.value)
sendToAnalytics({ name: 'FID', value: metric.value, id: metric.id })
})// ✅ New: INP monitoring (current Core Web Vital)
import { onINP } from 'web-vitals'
onINP((metric) => {
console.log('INP:', metric.value)
// Access the INP attribution for debugging
const attribution = metric.attribution
if (attribution) {
console.log('Event type:', attribution.interactionType)
console.log('Input delay:', attribution.inputDelay)
console.log('Processing time:', attribution.processingDuration)
console.log('Presentation delay:', attribution.presentationDelay)
console.log('Target element:', attribution.interactionTarget)
}
sendToAnalytics({
name: 'INP',
value: metric.value,
id: metric.id,
attribution: attribution
})
})Step 2: Update Your Performance Budgets
// lighthouse-budget.json — update responsiveness budgets
{
"budgets": [{
"timings": [
{
"metric": "interactive",
"budget": 3500
},
{
"metric": "total-blocking-time",
"budget": 300
}
]
}]
}// Performance budget translation:
FID good threshold: ≤ 100ms
INP good threshold: ≤ 200ms
TBT (lab hint, not a prediction):
High TBT often goes with a poor INP, but the two can disagree.
Confirm with field data or an interaction trace.Step 3: Update Your Dashboards and Alerts
// Custom RUM beacon with INP breakdown
function reportINPBreakdown(metric: any) {
const { attribution } = metric
fetch('/api/rum', {
method: 'POST',
body: JSON.stringify({
metric: 'INP',
value: metric.value,
rating: metric.rating, // 'good' | 'needs-improvement' | 'poor'
page: location.pathname,
// INP-specific breakdown (not available with FID)
inputDelay: attribution?.inputDelay,
processingTime: attribution?.processingDuration,
presentationDelay: attribution?.presentationDelay,
interactionType: attribution?.interactionType, // 'pointer' | 'keyboard'
target: attribution?.interactionTarget, // CSS selector of clicked element
timestamp: Date.now()
}),
keepalive: true
})
}Why Each INP Phase Matters for Debugging
INP breaks into three phases, and each calls for its own debugging approach: input delay, processing time and presentation delay.
Input Delay: Third-Party Scripts and Long Tasks
High input delay means the main thread was busy when the user interacted. The most common cause: third-party scripts (analytics, chat widgets, A/B testing) executing Long Tasks that block the event queue.
Debug approach:
// Identify what's blocking the main thread during input delay
const longTaskObserver = new PerformanceObserver((list) => {
for (const entry of list.getEntries()) {
if (entry.duration > 50) {
console.warn(`Long Task: ${entry.duration}ms`, entry.attribution)
}
}
})
longTaskObserver.observe({ type: 'longtask', buffered: true })Processing Time: Heavy Event Handlers
High processing time means your event handler code (React re-renders, state management, API calls) is taking too long to execute.
Debug approach:
// ❌ Heavy processing: synchronous data transformation in click handler
function handleFilterChange(filter: string) {
// Filters 10,000 products synchronously → 200ms processing time
const filtered = allProducts.filter(p =>
p.category === filter && p.price >= minPrice && p.inStock
)
setFilteredProducts(filtered)
updateURL(filter)
trackEvent('filter_change', filter)
}
// ✅ Fixed: defer non-critical work with scheduler.yield()
async function handleFilterChange(filter: string) {
// Critical: update visible UI immediately
setActiveFilter(filter)
setFilteredProducts(allProducts.filter(p => p.category === filter))
// Yield to the browser → allows next frame to paint
if ('scheduler' in globalThis) {
await scheduler.yield()
}
// Non-critical: run after paint
updateURL(filter)
trackEvent('filter_change', filter)
}Presentation Delay: Layout Thrashing and Paint Complexity
High presentation delay means the browser is spending too long recalculating styles, layout, and painting after your handler runs.
Debug approach:
// ❌ Layout thrashing: read/write cycle forces synchronous reflow
function updateMultipleElements(elements: HTMLElement[], newHeight: number) {
elements.forEach(el => {
const currentHeight = el.offsetHeight // Forces layout read
el.style.height = `${newHeight}px` // Forces layout write
// Next iteration: read triggers synchronous reflow because of prior write
})
}
// ✅ Fixed: batch reads, then batch writes
function updateMultipleElements(elements: HTMLElement[], newHeight: number) {
// Read phase (one layout calculation)
const heights = elements.map(el => el.offsetHeight)
// Write phase (batched, one reflow at end)
elements.forEach(el => {
el.style.height = `${newHeight}px`
})
}INP Optimization Strategies That FID Never Required
Because FID ignored processing time and presentation delay, many optimization techniques are new to the INP era:
| Strategy | Phase Targeted | FID Impact | INP Impact |
|---|---|---|---|
| Defer third-party scripts | Input Delay | ✅ Helped FID too | ✅ Critical |
scheduler.yield() in handlers | Processing Time | ❌ FID didn't measure | ✅ Critical |
requestAnimationFrame batching | Presentation Delay | ❌ FID didn't measure | ✅ Important |
React useTransition | Processing Time | ❌ FID didn't measure | ✅ Critical for React |
CSS contain: layout on dynamic elements | Presentation Delay | ❌ FID didn't measure | ✅ Important |
content-visibility: auto on long lists | Presentation Delay | ❌ FID didn't measure | ✅ Important |
// React useTransition — mark non-urgent state updates as transitions
import { useTransition, useState } from 'react'
function ProductFilter({ products }: { products: Product[] }) {
const [isPending, startTransition] = useTransition()
const [filtered, setFiltered] = useState(products)
function handleFilter(category: string) {
// Urgent: update the active filter button immediately
setActiveCategory(category)
// Non-urgent: filter the product list without blocking interactions
startTransition(() => {
setFiltered(products.filter(p => p.category === category))
})
}
return (
<div style={{ opacity: isPending ? 0.7 : 1 }}>
{filtered.map(p => <ProductCard key={p.id} product={p} />)}
</div>
)
}How BugViso Measures INP and Identifies the Worst Offenders
Monitoring INP requires capturing interaction metrics across real page sessions with JavaScript-driven interactions — something that automated crawlers with no user interaction cannot fully replicate for INP (since INP requires actual user inputs). However, the underlying main-thread bottlenecks that cause poor INP are measurable.
BugViso's audit engine captures the foundational metrics:
- Total Blocking Time (TBT) measurement via
PerformanceObserverLong Task detection on every crawled page, identifying pages with the highest main-thread blocking — a strong lab predictor of poor INP. - Core Web Vitals capture including LCP, CLS, FCP, and TTFB using the official
web-vitalslibrary, establishing the complete performance baseline for every crawled page. - Code coverage analysis via CDP precise JavaScript coverage tracking, quantifying unused bytes in each script — the dead code that inflates parse/compile time and increases input delay.
- Network throttling simulation under Slow 3G and Fast 3G profiles with CPU throttling, revealing how INP-related metrics degrade on constrained mobile connections and CPUs. These are lab numbers, not field data.
- Console error and exception capture that identifies JavaScript runtime errors from event handlers — broken interaction handlers that produce infinite INP (the interaction never completes).
More detail is on the Core Web Vitals checker feature page.
Frequently Asked Questions
Can INP be measured in lab tools like Lighthouse?
Not directly. INP requires real user interactions, which Lighthouse (an automated tool) doesn't produce.
Lighthouse reports Total Blocking Time (TBT), which works as a lab hint: a high TBT often goes with a poor INP, but the two can disagree, so don't treat TBT as a prediction.
For precise INP measurement, use Real User Monitoring (RUM) or the Chrome UX Report.
My FID was always under 30ms. Will my INP also pass?
Not necessarily. A low FID only means the main thread was idle when the user first interacted.
If subsequent interactions trigger heavy React re-renders, complex filtering operations, or layout-thrashing animations, INP will capture those delays — even if FID was perfect. Audit every interactive element, not just the initial page load.
Does INP affect ranking differently than FID did?
Google uses the same integration point for INP as it did for FID: it's one of the three Core Web Vitals that contribute to the Page Experience ranking signal.
INP is stricter than FID, so some pages that passed under FID can fail under INP. How much that moves rankings is debated; see do Core Web Vitals affect rankings.
What interactions does INP measure?
INP measures discrete interactions: clicks, taps, and keyboard inputs (keydown/keyup). It does not measure continuous interactions like scrolling, pinch-zoom, or drag gestures — these are handled by the compositor thread and don't block the main thread.
Hover events are also excluded.
How do I find my worst INP interaction?
Use the web-vitals library with attribution enabled. The metric.attribution.interactionTarget property returns the CSS selector of the element the user interacted with when the worst INP was recorded.
In production RUM, log this selector alongside the INP value to identify which specific button, input, or link is causing the highest latency. A BugViso audit captures TBT and Long Task counts as the lab-measurable foundation for diagnosing INP bottlenecks.
Written by
Kazi Khalid Hasan Tamim · BugViso Team
Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.
Summarise with AI
Open this guide in your assistant.
Follow BugViso
New guides and audit data as we publish them.
AI visibility tracker
Is your brand in AI answers?
See how often AI assistants mention you, cite your site and rank you against your competitors.
- ChatGPT
- Gemini
- Perplexity
- Claude
- AI Overviews
See where your site stands
Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.