
INP – The "Responsiveness" Index Your Website May Be Missing: Core Web Vitals' Guide to Instantly Responsive Interface Design
Have you ever clicked the "Add to cart" button on a website, waited a beat, nothing changed, then clicked again and the cart ended up with two products instead of one? Or open the menu on your phone and feel like the screen "freezes" for half a second before the menu slides out? Those frustrating moments have an official name in the world of web optimization: interaction lag. And since March 2024, Google has included it in the Core Web Vitals index set under the name INP - Interaction to Next Paint, replacing the old FID (First Input Delay) index. This change seems small, but it causes many websites with elaborate interface investments to suddenly be labeled "needs improvement" or "poor" in Google Search Console.
To understand why, it is necessary to clearly distinguish two indicators. FID only measures the latency of the first interaction, and only the time the browser has to wait before it starts processing the event. A website can achieve a very good FID just because the user happened to click on it while the browser was idle. INP is much more rigorous: it observes nearly all mouse clicks, screen touches, and keystrokes throughout the user's time on the page, then takes the slowest value to represent it. Furthermore, INP measures a complete cycle consisting of three phases: input delay, processing time for the JavaScript code associated with the event (processing time), and time for the browser to redraw the next frame (presentation delay). According to the threshold published by Google, INP below 200 ms is considered good, from 200 to 500 ms is in need of improvement, and above 500 ms is poor. In other words, each interaction on a website needs to provide the user with visual feedback in less than the blink of an eye.
The most common culprit that causes INP to exceed the threshold is long tasks on the main thread of the browser. The browser only has one main thread to both run JavaScript, calculate the layout, and draw the interface. When a piece of code runs continuously for more than 50 milliseconds – for example, an ad tracking script, a third-party chat widget, or a product filter function that traverses thousands of elements – every user click during that time is queued. E-commerce websites and business websites that integrate too many marketing tools are typical victims: each tool only "weighs a little", but cumulatively creates a barrier that blocks all feedback. The second reason is that the DOM tree is too large. A home page with tens of thousands of HTML buttons, many layers of nested divs and complex CSS effects will cause each interface update to take a lot of time to recalculate the layout and redraw.
So what principles should be followed to design a website that achieves good INP? The first principle is visual feedback first, heavy processing later. When the user presses a button, the interface must immediately change – the button switches processing status, the shopping cart icon jumps, the start menu opens – while time-consuming tasks such as sending analytics data, calling APIs or recalculating the list are pushed to the next frame. Technically, programmers can split the task by ceding control to the browser (yielding) through APIs like scheduler.yield() in supported browsers, or using setTimeout and requestAnimationFrame as backup plans. For applications built with React, mechanisms like startTransition allow non-urgent updates to be flagged so that the interface responds to the user first.
The second principle is to tightly control third-party JavaScript. Each chat code, tracking code, and product review code should be reviewed to see if it is truly necessary on every page, and should be delayed loading after the page has become interactive. Centralized management through Google Tag Manager also helps technical teams easily measure the impact of each tag. The third principle is to reduce DOM size and avoid operations that cause "layout jerks" such as reading and writing element sizes continuously in a loop. With long lists such as catalogs of thousands of products or data tables, the virtualization technique of displaying only the elements that are in the viewport will significantly reduce the load on the browser. The CSS content-visibility property is also a useful tool for browsers to skip drawing off-screen content blocks.
The fourth principle is to measure using real user data, not just based on lab scores. The Lighthouse tool running on the programmer's computer cannot fully simulate the touch behavior of thousands of users on mid-range phones. INP therefore needs to be monitored through real data (Real User Monitoring) from the Core Web Vitals report in Google Search Console, the Chrome UX Report data set, or the web-vitals library attached directly to the website to record which interactions are slow, on which pages and on what types of devices. The Performance tab in Chrome DevTools allows you to visualize and dissect each slow interaction to find the exact JavaScript function that is causing the bottleneck.
The most important thing to remember is that INP is not just a technical number for SEO. It is a direct measure of the customer's feeling of "is this website responsive?" A responsive website creates a sense of quality and trust, encouraging users to explore further, add products to their carts and complete checkout. On the contrary, just a few clicks without a response is enough to make customers suspect the website is faulty and leave. Therefore, when ordering a new website design project, businesses should include an INP threshold of less than 200 milliseconds on mobile devices in the acceptance criteria from the beginning, instead of waiting until the website is operational to detect and patch up repairs.