What Is First Input Delay (FID)? What to Know About This Ranking Factor

If you run an online store or manage a website, your site’s first impression on users could make or break your conversions. Your web design attracts and appeals to users, while a page’s speed and responsiveness make them stay. While it’s difficult to measure if users like your web design using web API, Google made it easier to track your site’s responsiveness using the Core Web Vitals metrics (CWV). One of these metrics is First Input Delay (FID).

But what is First Input Delay? If you want to optimize how users interact with your web page, you’ll want to focus on it. This guide helps you understand FID basics, including how to measure and optimize your FID to improve your SEO and user experience.

Key Takeaways

  • First Input Delay (also called Input Latency) is a user experience metric that measures the delay between a user’s action and the page’s reaction to this interaction.
  • It tracks the time you click a link on a page until the time the browser responds and processes event handlers to your interaction.
  • You can measure FID with an input delay test. Tools to use for this include Chrome User Experience Report, the Search Console Core Web Vitals report, Page Speed Insights, and Lighthouse.
  • Main causes of FID include large JavaScript that prevents your browser from running event listeners, as it’s too busy executing the current code in the main thread, and bad coding.
  • Having a good FID score is important because it makes a good first imporession on web visitors, improves user experience, and increases your SEO rankings.
what is first input delay

What Does First Input Delay Mean?

First Input Delay (FID), which is a part of Google’s Core Web Vitals, is a metric that measures the time between an initial user interaction on your page and when the browser begins processing that action. FID could be anything from clicking a link to typing into a search field or filling out an online form. However, actions like scrolling, zooming, and moving the mouse don’t count since it doesn’t require a response from the page.

The goal of FID is to measure the amount of time it takes for the interaction with your site to be processed, so that response times are as fast as possible. The importance of FID comes down to user experience. No one likes waiting around for a website to load and process their actions, so the faster you can make your FID, the better your user experience will be. Google has set a benchmark goal of 100 milliseconds — anything above this number means that users are having trouble interacting with your site quickly and easily.

Why You Should Care About First Input Delay

First Input Delay is one of the most exciting web performance metrics to track since it requires real user input. (And real user input includes clicks and filling out forms.) You can’t simulate it using tools, making it a good metric for engagement. Aside from this, here are a few more reasons to understand and optimize your FID.

Makes a Good First Impression

FID measures responsiveness, which is one of the critical indicators of a site’s user experience and reliability. Improving your FID leaves a good impression on users and generally leads to higher conversions.

Improves User Experience

The most common interactivity issues happen during page load, and when users experience slow loading speeds, it affects their user experience negatively. Optimizing your site’s first user interaction will help users engage with your page efficiently and give them a better user experience.

Helps Developers Fix Issues

Understanding First Input Delay against other web performance metrics will enable you to provide developers with specific guidelines to resolve input delays. After all, solutions for high FIDs differ from slow input delays after loading a page.

Increases SEO Ranking

FID is one of the real user metrics that’ll help you track real user engagement and help improve your user experience. In turn, it’ll contribute to your site’s SEO ranking. Since First Input Delay is part of Google’s Core Web Vitals, it’s an official ranking factor for your website, which means it should be a crucial component of your SEO strategy. The other Core Web Vitals metrics include Cumulative Layout Shift (CLS) and Largest Contentful Paint (LCP).

How to Test and Measure FID

first input delay FID

There are two methods that can be used to measure FID. Note that regardless of which method you choose, all of the options below allow you to measure First Input Delay, along with other metrics. So it all depends on what metrics you want to track besides FID and how you want to track them.

Use FID Tools

Here are four tools you can use to measure your FID data.

Chrome User Experience Report

The Chrome User Experience Report provides developers, marketers, and businesses with user experience metrics from real-world user engagement from Google Chrome.

Search Console Core Web Vitals Report

The Core Web Vitals report from the Google Search Console offers information on how your website performed in the past 90 days based on the Core Web Vitals criteria. Also, this tool is a powerful platform to check and optimize your site’s overall web performance.

PageSpeed Insights

PageSpeed Insights provides a full report of a page’s speed performance by inputting a URL. It includes data for First Input Delay, other CWV metrics, and suggestions to improve your page for mobile and desktop.


Lighthouse in Chrome DevTools provides an automated, open-source tool that reports any web page’s performance, loading speed, interactivity, SEO, and more. It also offers recommendations to optimize your user experience.

Add JavaScript to the Web Page

If you want to measure FID using JavaScript, you can do it in two ways. First, you or your developers can use the web vitals JavaScript library. It’s a library specifically for front-end monitoring, and it’s an effective and accurate tool that lets you track your performance during short periods.

Second, you can add PerformanceObserver manually on your track input. It’s a web API that tracks performance measurement events as they happen. If you don’t want to import the library, you may use the Event Timing API to manually track your First Input Delay.

Track Your First Input Delay Score

Tools measure FID in milliseconds (ms). If you want to provide a good user experience, you should hit an FID of 100 ms (0.1 sec) or less. It’s the limit to making users feel that your page responds instantaneously. 

Google sets the following benchmarks on PageSpeed Insights:

  • Good: 100 ms or less
  • Needs improvement: 100-300 ms
  • Poor: 300 ms and above

Sometimes, pages will score 100 ms or less but still feel unresponsive. If this happens to you, know that FID doesn’t measure the process of running the task related to the user input. Not all users interact with a page, and FID doesn’t measure all interactions. Plus, user interactions can come anytime, including when the main thread is busy and when the main thread is idle. As a result, users will have high or low FID values, and some will have no FID values. Consider these factors when tracking, reporting, and analyzing First Input Delay.

Leading Causes of First Input Delay

Input delay occurs when the browser’s main thread doesn’t respond to the user input since it’s busy with a task. For a deeper look at why this happens with the main thread, here are the two main causes of First Input Delay.

Heavy JavaScript

Large JavaScript is one of the main causes of long First Input Delays. It includes the initial payload and ongoing execution. It prevents your browser from running event listeners, as it’s too busy executing the current code in the main thread. Since the current JavaScript code can change the browser’s actions, the browser will have to wait for all referenced JavaScript to load, making the website feel unresponsive.

So, if you have long input delays, your page may have numerous images or scripts loading randomly, excessive third-party apps, or unnecessary code. You can optimize your web pages by simplifying the JavaScript on your web pages.

Long JavaScript Tasks

After loading all the JavaScript, you can still experience First Input Delay since long-running tasks will continue on the main thread. It can’t accept user inputs until the main thread can handle the information. This issue is usually due to poorly optimized code or badly executed third-party code. The processing speed and power of a user’s device may also affect your FID, but it’s out of your control.

How to Improve First Input Delay

Using the recommended tools above, you’ll also receive suggestions on optimizing your First Input Delay for a better user experience. Here are some of the most common ways to improve your FID.

1. Utilize Asynchronous Tasks if Possible

If you have heavy JavaScript, try to break down long tasks into small, asynchronous tasks. Long tasks refer to code that blocks a browser’s main thread for 50 milliseconds and more. It’s a sign of JavaScript bloat, where a page may be processing more tasks than the user currently needs. As a result, the browser can’t process user input immediately. So, look for code you can break down to allow the user input to process in the main thread.

2. Optimize CSS Code and Third-Party Scripts

JavaScript code is often the root of the issue. However, your page’s CSS code can also block your user input from processing on the main thread. To resolve this, minify and compress your CSS files, and remove unused code. Reducing your CSS decreases the file size, making it quicker to download and render on the page.

Also, you may want to check third-party scripts from installing analytic services and pop-up ads, as they can affect your page’s load performance and FID. Consider prioritizing third-party codes that matter to your page.

3. Minimize Polyfills

Polyfills are codes that allow your page to function on older browsers. If a page doesn’t need them, prevent them from running to improve your loading performance. You may also remove polyfills you’re not using to optimize your FID further. Consider using only the polyfills you need.

4. Defer Unused JavaScript

All JavaScript files are render-blocking, which means they prevent the browser from loading quickly. A browser must download, analyze, compile, and execute a JavaScript file. Use “defer” or “async” to run the script only when the page needs it. If you use Chrome DevTools, check the Coverage Tab to see which parts of your script you should defer or omit.

5. Use Server-Side Processing

Try using server-side or back-end processing to reduce the amount of data users need to load on their browsers. However, note that large script executions can block user engagement on server-side rendered apps. So, consider transferring more logic to the server side or generating static content to reduce FID.

6. Optimize Images for Performance

Images don’t affect a page’s responsiveness. However, you can use lazy-loading, which is the process of delaying images and other resources. This helps free up bandwidth for code transferring, resulting in a faster loading speed. If you’re using a CMS like WordPress or Drupal, you can use their image optimizers for your convenience.

Frequently Asked Questions

What Is an Acceptable FID Score?

A good FID score is 100 milliseconds or less. Loading at 0.1 seconds is the maximum amount of time you need to hit to make your pages feel instantaneously responsive. When checking First Input Delay scores, consider the following benchmarks from Google to see your current status: good: 100 ms or less; needs improvement: 100-300 ms; poor: 300 ms and above.

What’s the Difference Between First Input Delay and Time to Interactive?

First Input Delay (FID) tracks the time or delay between when a user interacts with a page and when the page responds to it, capturing the critical stage of early user interaction. Meanwhile, Time to Interactive (TTI) is a web performance metric that measures how long it takes for a page to be ready for interaction. It includes when a page registers valuable content and event handlers for most page elements.

How Much Does FID Affect SEO?

First Input Delay is a small ranking factor, as there are plenty of factors Google considers when ranking pages. However, since it’s within your control, consider focusing on it to improve your user experience and overall SEO performance.

Give Your Site Visitors a Better Experience

So, what is First Input Delay? It measures the delay between a user’s input and the page’s response to the interaction. It’s important because it measures how quickly users get feedback after interacting with your website — the faster this feedback loop is, the better user experience visitors will have while navigating around your site.

Identifying and optimizing your FID will help you improve your user experience and make a better first impression on your site visitors. Ultimately, Google’s SEO metrics continuously change. It’s smart to stay up to date with the latest Google ranking factors to maintain and improve your site’s overall search engine performance.