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.

· 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:

PhaseWhat HappensMeasured by FID?Measured by INP?
Input DelayMain thread is busy; user input waits in queue✅ Yes✅ Yes
Processing TimeEvent handler executes (your onClick code runs)❌ No✅ Yes
Presentation DelayBrowser 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.

typescript
// 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 ScoreRatingUser Perception
≤ 200ms🟢 GoodInteraction feels instant
201–500ms🟡 Needs ImprovementNoticeable delay, user may retry
> 500ms🔴 PoorInteraction 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.

text
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

typescript
// ❌ 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 })
})
typescript
// ✅ 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

json
// lighthouse-budget.json — update responsiveness budgets
{
  "budgets": [{
    "timings": [
      {
        "metric": "interactive",
        "budget": 3500
      },
      {
        "metric": "total-blocking-time",
        "budget": 300
      }
    ]
  }]
}
text
// 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

typescript
// 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:

typescript
// 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:

typescript
// ❌ 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:

typescript
// ❌ 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:

StrategyPhase TargetedFID ImpactINP Impact
Defer third-party scriptsInput Delay✅ Helped FID too✅ Critical
scheduler.yield() in handlersProcessing Time❌ FID didn't measure✅ Critical
requestAnimationFrame batchingPresentation Delay❌ FID didn't measure✅ Important
React useTransitionProcessing Time❌ FID didn't measure✅ Critical for React
CSS contain: layout on dynamic elementsPresentation Delay❌ FID didn't measure✅ Important
content-visibility: auto on long listsPresentation Delay❌ FID didn't measure✅ Important
typescript
// 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 PerformanceObserver Long 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-vitals library, 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

· 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.

Found this useful? Share it.

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 how it works

See where your site stands

Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.