FID (First Input Delay)

First Input Delay (FID) is a Core Web Vital that measures the time between a user's first interaction with a page — clicking a button, tapping a link, pressing a key — and the moment the browser begins processing that event. It captures responsiveness rather than visual loading speed. A good FID score is under 100 milliseconds, meaning the page feels instant to the user. Anything above 300 milliseconds is considered poor. FID specifically measures input delay caused by the browser's main thread being busy with other tasks, such as parsing JavaScript or executing long-running scripts. It does not measure the time it takes for the browser to finish processing the event or update the UI afterward.

When a reader clicks a button and nothing happens for a noticeable moment, the page feels broken. Slow input response frustrates users and increases [bounce rates](/glossary/bounce-rate). Google has used FID as a ranking signal within its Core Web Vitals assessment, so pages with poor FID may rank lower in search results. For publishers sharing flipbooks and interactive documents, a sluggish first interaction undermines the professional impression your content is meant to create. Mobile users are especially affected because mobile devices often have less processing power, making main-thread congestion more noticeable.

FlipLink flipbooks are optimized to keep FID low by deferring non-critical JavaScript until after the initial render. The Three.js page-flip engine loads progressively, so the viewer toolbar and navigation controls respond immediately when a reader first interacts. Tracking pixels and analytics scripts are loaded asynchronously to avoid blocking the main thread. When you [embed a flipbook](/glossary/responsive-embed) on your own website, FlipLink's embed code uses lazy loading and asynchronous initialization so the flipbook does not add input delay to your host page. These optimizations ensure that embedded and shared flipbooks feel responsive from the first click, whether viewed on desktop or mobile.

| Rating | FID Threshold | What It Means | |--------|--------------|---------------| | Good | ≤ 100 ms | Page responds instantly to input | | Needs Improvement | 101–300 ms | Noticeable delay before response | | Poor | > 300 ms | Page feels unresponsive or frozen | FID is measured at the 75th percentile of page loads in the Chrome User Experience Report (CrUX). This means 75% of your visitors must experience a FID of 100 ms or less for your page to pass the "good" threshold. You can measure FID using Google PageSpeed Insights, Lighthouse, or the Web Vitals JavaScript library in your own analytics setup.

FID measures only the delay portion of event processing — the gap between the input event firing and the browser starting to run the event handler. It does not include the time the handler takes to execute or the time for the browser to repaint the screen. The most common cause of high FID is long JavaScript tasks on the main thread. When the browser is busy executing a script that takes 200 ms or more, any user input during that window is queued and delayed. Common sources of main-thread blocking include: - **Large JavaScript bundles** parsed and compiled on page load - **Third-party scripts** (analytics, ads, chat widgets) executing synchronously - **Heavy DOM manipulation** during initial render - **Unoptimized web font loading** that triggers layout recalculations To reduce FID, break long tasks into smaller chunks, defer non-essential scripts, use code splitting to load only the JavaScript needed for the current view, and minimize third-party script impact.

Google officially replaced FID with [Interaction to Next Paint (INP)](/glossary/core-web-vitals) as a Core Web Vital in March 2024. While FID measures only the first interaction, INP measures the responsiveness of all interactions throughout the entire page lifecycle and picks the worst one (or near-worst for pages with many interactions). This makes INP a more comprehensive responsiveness metric. Key differences: - **Scope**: FID measures the delay of the first interaction only. INP measures every interaction (clicks, taps, key presses) and reports the worst. - **What is measured**: FID measures only input delay (time before the handler runs). INP measures the full duration from input to the next visual update (paint). - **Threshold**: Good FID is ≤ 100 ms. Good INP is ≤ 200 ms. - **Status**: FID is deprecated as a Core Web Vital but still reported by many tools. INP is the current official metric. Even though FID is no longer a Core Web Vital, the optimizations that improve FID — reducing main-thread blocking, deferring scripts, code splitting — also improve INP. FlipLink's viewer is optimized for both metrics.