First Input Delay, commonly abbreviated as FID, is a performance metric that measures the delay between the moment a user first interacts with a web page and the moment the browser is able to begin processing that interaction. This interaction may be clicking a link, tapping a button, entering text into a form field or using a JavaScript-powered control. FID helps evaluate how responsive a website is at the first moment of user interaction.
FID does not measure how long it takes for the entire action to be completed after a user clicks a button. More accurately, it measures how long the browser is delayed before it can start processing the user’s first interaction because the main thread is busy. For example, if a user clicks a button while the page is loading and the browser is busy executing a large JavaScript file, it may not be able to respond immediately. This waiting time is measured as First Input Delay.
First Input Delay is important because it affects the user’s first impression of interactivity. A page may appear visually loaded, but if nothing happens when the user clicks a button, opens a menu or types into a form field, the experience becomes negative. From the user’s perspective, it is not enough for the page to be visible; the page should also respond quickly to interactions. For this reason, FID has been an important performance indicator, especially for JavaScript-heavy websites.
FID was previously used as one of the Core Web Vitals metrics. However, as of March 12, 2024, Google replaced FID with Interaction to Next Paint, or INP, as a Core Web Vital. The reason is that FID measures only the delay of the first interaction, while INP provides a broader evaluation of responsiveness by observing click, tap and keyboard interactions throughout the page visit. Therefore, in current performance analysis, focusing on INP instead of FID is a more accurate approach.
The historical thresholds for FID were clear. A FID value of 100 milliseconds or less was considered good. Values between 100 and 300 milliseconds were considered as needing improvement. FID values above 300 milliseconds indicated a poor user experience. In this metric, a lower value is better and a higher value is worse. Therefore, a high FID score does not mean good performance; it means the user waits longer before the page can respond to the interaction.
The main cause of FID problems is usually a busy browser main thread. Downloading, parsing and executing large JavaScript files are among the most common reasons for this delay. Third-party scripts, ad tags, analytics code, heavy frameworks and long tasks can also delay the browser’s response to the user’s first interaction. Even if the page appears visually loaded, intensive background processing can block the user’s interaction.
FID issues often occur between First Contentful Paint and the point when the page becomes reliably interactive. At this stage, the user has started to see some content on the page, but all JavaScript work may not yet be complete. If the user clicks a button or starts entering information into a form at that moment, the browser may need to finish the current long task first. This increases First Input Delay and can make the page feel slow.
To improve FID, the JavaScript workload should be reduced. Unused JavaScript should be removed, large files should be split into smaller chunks, non-critical scripts should be deferred and third-party code should be managed carefully. Long tasks can be broken into smaller parts, operations that block the main thread can be reduced and solutions such as Web Workers can be used where appropriate. Loading only the resources that are truly necessary during the initial page load can also help improve interaction speed.
FID can only be measured when a real user interaction occurs. For this reason, it is not always possible to measure FID directly in lab tests. If a user does not interact with the page, there may be no FID value for that session. In the past, metrics such as Total Blocking Time were used in lab environments to estimate issues that could affect FID. Today, INP should be monitored to analyse overall responsiveness more effectively.
In summary, First Input Delay is an important performance metric that measures how quickly the browser can begin responding to a user’s first interaction with a web page. Although it was historically part of Core Web Vitals, it has now been replaced by INP in current evaluations. However, the core issues indicated by FID are still important: excessive JavaScript, a blocked main thread, long tasks and delays caused by third-party scripts. For a better user experience, a page should not only appear quickly but also respond quickly to user interactions.
