First Input Delay is a web performance metric used to check how fast a page reacts when someone first tries to use it. It looks at the time between a user’s first action, like clicking a link or button, and when the browser starts handling that input. A low First Input Delay means the page responds quickly, while a long delay means it feels stuck or slow.

Google introduced First Input Delay (FID) in 2020 as part of Core Web Vitals, focusing on page interactivity. A good FID is under 100 milliseconds, which feels almost instant to most users. FID became a ranking factor in search as part of the page experience signal.

But FID has a limit: it only checks the very first click or tap. It does not show how a site handles actions after that. Because of this, Google later replaced it with Interaction to Next Paint (INP) in 2024, which tracks a wider set of user interactions for better accuracy. FID is now deprecated in performance tools and guidance.

How First Input Delay started

First Input Delay started as a way to measure how quickly a webpage reacts when someone first clicks or taps. Google introduced it in 2018 to help developers track real-world responsiveness during the loading phase.

Early performance focus

Before 2018, most web performance metrics focused on page load speed and visible changes, such as First Contentful Paint (FCP). These metrics showed when something appeared on the screen but did not measure how quickly the page responded to a user action.

Google introduced First Input Delay

In 2018, Google started testing First Input Delay (FID) as a new user-focused metric. It tracked how fast a page reacted to the very first tap, click, or input. This testing used real user data collected through the Chrome User Experience Report (CrUX). Developers could also try it through an origin trial using the PerformanceObserver API.

FID became part of Core Web Vitals

In May 2020, Google officially added FID to its set of Core Web Vitals, along with:

• Largest Contentful Paint (LCP) – for loading speed
• Cumulative Layout Shift (CLS) – for visual stability

FID was chosen to show how responsive a page is when someone first interacts with it.

Tools and search ranking update

Google added Core Web Vitals to its tools such as Lighthouse, PageSpeed Insights, and Search Console. In 2021, Google made these metrics part of its search ranking signals through the page experience update.

Impact on developer focus

After FID became important for search ranking, many web developers worked on reducing JavaScript delays and main thread blocking. These changes helped make sites respond faster to users during the loading stage.

What First Input Delay means and how it is measured

First Input Delay tells us how long a page takes to respond when someone first tries to use it. It checks the delay between the first click or tap and the moment the browser starts reacting to that action.

Definition of First Input Delay

First Input Delay (FID) measures how long a person waits after their first action—like a click, tap, or key press—before the browser starts handling it. It tracks the time between the input event and when the main thread begins the event handler. If the browser is busy running other work, the user has to wait. This is the delay FID captures.

When delay happens

If a large script is still running during a user’s first input, the browser cannot respond right away. The input must wait until that task finishes. This blocked time creates a high FID. If the main thread is free or only slightly busy, the delay is short and the site feels fast.

Which actions count

FID only looks at the first input event. It counts simple actions like:

• Clicking a button
• Tapping a link
• Pressing a key

It does not measure:

• Scrolling
• Pinching to zoom
• Dragging or swiping

Also, it only measures the delay before the browser responds, not how long the site takes to finish the work or show results.

Field metric only

First Input Delay is a field metric. It works only when a real user interacts with the page. It cannot be tested in a lab without a person. Developers use lab tools like Total Blocking Time (TBT) and Time to Interactive (TTI) to guess how slow or busy the page might be. But these tools only simulate conditions and do not capture exact user input timing.

Why FID mattered

Google included FID in Core Web Vitals because it shows a real user’s experience. A good FID means the site reacts quickly when it matters most—during the first tap or click while the page is loading.

What makes a good FID

Google advised site owners to aim for:

• Good: FID less than 100 milliseconds
• Needs improvement: Between 100 ms and 300 ms
• Poor: Above 300 milliseconds

These values were based on the RAIL model for performance, where fast response under 100 ms feels instant to the user.

How to improve FID

To keep FID low, developers were asked to:

• Reduce JavaScript execution time
• Split long tasks into smaller ones
• Let the main thread stay free during loading

This way, the browser could respond quickly if a user interacts early.

Device impact

Mobile devices or pages with heavy scripts often show higher FID. On slower phones or tablets, even short tasks can block input. Many fast sites still had good FID because users clicked only after the page became idle.

Example case

If a user taps a button that starts an animation, FID only checks how long it takes before the browser starts the click function—not how long the animation runs or when new content appears. This helps developers see whether the delay came from browser blockage or from later content changes.

Design purpose

By measuring only the initial input delay, FID shows how ready the browser is to respond—not the full effect of the interaction. This helps developers fix the real issue: browser blockage during load.

Common Challenges and limitations of First Input Delay

First Input Delay helped track early page response, but it had limits. It measured only the first click delay and missed all later actions. This made it less useful for understanding full user experience across a session.

Measured only the first interaction

First Input Delay (FID) focused only on the first input event—like a tap or click—during page load. It did not track any delay that came later. If a person clicked only after the page became mostly idle, the FID looked fast, even if the rest of the site felt slow.

Missed later delays

A page might run heavy scripts or do big UI updates after the first click. But FID did not count those. It only measured how fast the browser started handling the first event. It did not include time spent running the event handler or updating the screen, which also affect how responsive a site feels.

Did not match full experience

Because it skipped all later delays, FID gave a partial view of how a site behaves. It did not reflect what users feel across a session. A good FID did not always mean good performance.

Depended on user behavior

FID worked only if a person interacted early. If no action happened during page load, then no FID was recorded. This made the data uneven. Pages that loaded slowly but got clicked after everything was ready could still show a “good” FID—even if users felt frustrated waiting.

Not easy to test in labs

FID could not be tested in a lab environment. Developers had to use other tools like Total Blocking Time (TBT) or Time to Interactive (TTI) to guess what FID might be. But these lab metrics did not track real user input. So, some sites passed lab tests but had slow FID in the field.

Not always tied to satisfaction

Early studies found that FID did not always match user happiness. Some called it modest in predicting real-world experience. Tools like Lighthouse later improved, but the lack of a full input-based lab test stayed a pain point.

Pushed search for better metric

By 2021, Google’s team said FID should be extended to cover all input events, not just the first. That goal led to the creation of a new metric designed to fill the gaps left by FID.

How First Input Delay made an impact

First Input Delay became important when Google made it part of Core Web Vitals. It helped developers fix slow clicks and page delays. Later, Google replaced it with a better metric called Interaction to Next Paint (INP).

Why developers focused on FID

When First Input Delay (FID) became part of Core Web Vitals in 2020, it drew wide attention. Tools like PageSpeed Insights, Lighthouse, and Search Console began showing FID scores. Many websites added FID to their performance budgets. Developers used ideas like code splitting, cutting large JavaScript tasks, and removing unused third-party scripts to keep the main thread free.

Used beyond engineers

Since FID scores affected Google search ranking, it was not just a developer metric. SEO teams and product managers also began to track it. FID became an easy way to explain interactivity delays, using one number measured in milliseconds. The result was a broader shift to user-first performance metrics.

FID helped set better practices

By focusing on first actions, FID reminded teams that click response time matters, not just page load speed. Even though most real-world FID scores were already under 100 ms, the metric helped spot pages that performed poorly on mobile or had large startup scripts.

Shift to Interaction to Next Paint

As more data came in, Google saw that FID missed later interactions and did not measure the full event duration. In 2022, it introduced Interaction to Next Paint (INP) as a new metric. Unlike FID, INP tracked all user actions on a page and included:

• Input delay
• Handler execution
• UI update

INP reported the worst-case delay or 95th percentile. This gave a more complete view of site responsiveness.

Official replacement

Google announced in 2023 that INP would replace FID. The change took effect in March 2024, with INP added to Core Web Vitals and FID removed. Major tools stopped reporting FID, including:

• Chrome UX Report
• PageSpeed Insights
• web-vitals.js

The browser still supports the PerformanceObserver entry for “first-input”, but it no longer shows up in public tools.

FID’s role in performance evolution

FID ran from 2020 to 2024 as a key metric. It made input latency a focus area and led to better practices around main-thread blocking. It was later replaced not because it failed, but because user input metrics needed to improve. INP now builds on that base to track overall page responsiveness.