Google’s New Core Web Vital Metric - How to enhance Interaction to Next Paint (INP)?

Google’s New Core Web Vital Metric - How to enhance Interaction to Next Paint (INP)?
By: Skynet Technologies USA LLC
Sep 04, 23
Sep 04, 23
interaction to next paint

Google Core Web Vitals are the metrics to assess and measure a website’s overall performance on a user’s query or action.

The three metrics such as

  • CLS (Cumulative Layout Shift)
  • FID (First Input Delay),
  • LCP (Largest Contentful Paint)

INP (Interaction to Next Paint) is a newly added metric, which will replace FID (First Input Delay) from March 2024.

INP refers to the assessment metric for a page’s overall responsiveness to user interactions. It means the time a page takes to respond to all clicks and keyboard interactions during the complete lifespan of a user’s visit to a page. The longest observed interaction gives you the final INP value wherein outliners are ignored.

The cumulative reports of Core Web Vitals tell you about pain points of the website that need to be fixed and INP will be one of them in some time.

YOU MIGHT ALSO LIKE: Google Core Web Vitals

Is INP different from FID and why Google has changed it?

As written above, INP is about a web pages’ all interactions by users whereas FID (First Input Delay), as its name refers, only considers the page's first interaction. It means, FID only measures the delay in the first interaction’s input and neither the time a page takes to run event handlers (such as pointerup, pointerdown, click, etc.) nor the delay in displaying the next frame.

Interaction to Next Paint (INP) is not only about first impression; it samples all interactions and then assesses web page responsiveness, which makes it a more comprehensive and reliable Core Web Vital metric than FID.

How does an INP work?

As soon as a visitor clicks or taps on a web page, an interaction begins, which might change the presentation or display on the screen. The INP (Interaction to Next Paint) measures the time in between the click and the presentation of every element on the page.

A single interaction’s latency comprises the single longest duration of an event which is a part of the interaction wherein duration is measured from the first point where the user began interacting with the page until the subsequent frame appears post all associated event handlers have executed.

The INP duration is the total timespan of the following:

  • The input delay (blocking task) – is the time between the user's first interaction with the page and event handlers’ execution.
  • The processing time – is the total sum of time taken in executing the code in associated event handlers.
  • The presentation delay – is the time between event handlers' work completion and frame presentation in the browser.

YOU MIGHT ALSO LIKE: How to improve Largest Contentful Paint (LCP)?

Set value of Interaction to Next Paint (INP) – the good and poor score!

INP measures a page's responsiveness effectively; thus, it is arbitrary to label its values as good or bad. However, you must know if some of the elements on the website need your attention and thereby Google has defined values for INP responsiveness.

To check if your web pages are delivering a good user experience, below values are to be considered -

  • If INP is below or at 200 milliseconds, the page has good responsiveness.
  • If INP is between 200 and 500 milliseconds, page responsiveness needs improvement.
  • If INP is above 500 milliseconds, the web page has poor responsiveness.
google interaction to next point

Know, what is an interaction?

Simply, it is an event that is done by a user such as a mouse click, a touchscreen tap, or a keystroke. Thus, whenever a user clicks, taps, or presses a key on the keyboard while browsing a web page, INP considers it as an interaction.

Though interactivity is mostly generated by JavaScript, however, browsers also provide interactivity via some controls that are not powered by JavaScript, for example, radio buttons, controls generated by CSS, etc.

Hovering and scrolling are not considered as interactions in INP. However, scrolling like page up, page down, etc. which involves keystrokes that trigger other events is calculated to measure INP.

YOU MIGHT ALSO LIKE: What questions to ask SEO company?

How to measure Interactions to Next Paint (INP)?

There are two main ways to measure INP; using field tools (real-user monitoring) and lab tools (synthetic tracking). However, field tools or real-user monitoring (RUM) give more accurate results.

RUM helps to gauge user interactions with your website or application by providing a quantitative measurement of page load time and interaction with a frame. This method works when a user downloads a small code of JavaScript while accessing a page. The code runs on the user’s device and sends the results to the RUM servers for processing.

Google also measures real Chrome user experience (CrUX), which is different from RUM. The CrUX is a data about 28-day sliding window of website traffic and you cannot change this timeframe to check the reports on user experience. Data gets stored for each month, and you can see the previous month's data while the current month's data is being stored.

Whereas RUM reports allow you to check the data in lesser time. You can set its timeframe to record the data, but it is suggested to look for 28 days performance if comparing CrUX and RUM data.

One more way to measure INP is by measuring the current session through Lighthouse in ‘timespan’ mode. Core Web Vital Visualizer or Google Web Vitals JavaScript Libraries can be also used to measure INP.

Analyse the INP using Web Vitals JavaScript Library

<script type="module">
 import {onINP} 
 from '';

Here are a few field tools that you can use for INP calculation –

  • PageSpeed Insights
  • Chrome User Experience Report
  • JavaScript Library (Web Vitals)

And some lab tools –

  • Lighthouse npm module
  • Lighthouse user flows
  • Web Vitals extension for Chrome

YOU MIGHT ALSO LIKE: How to improve Cumulative Layout Shift (CLS)?

How to improve Interactions to Next Paint (INP)?

You must ensure that each interaction on a web page responds properly thereby INP doesn’t get affected. Interactions to Next Paint is a complicated metric and improving its performance is crucial for website seamless execution.

1. Avoid putting long tasks on the main thread!

The page-starting phase is the most crucial and that is the part when most of the thread work is completed such as parsing, decoding, rendering, and scripting. Thus, often page becomes less responsive.

To reduce the load on the main thread:

  1. Remove unused code by tree shaking and code splitting so that remaining code will load swiftly whenever they are needed.
  2. Non-essential code can be loaded when the browser is in an idle state.
  3. If there are slow scripts that take many resources; rewrite them.
  4. Avoid too many or colossal images, videos’ CSS animations, or large DOM sizes so that the page will be easy to render.

2. Processing time should be less to ensure page direct response to user input!

If a user performs an action on a web page such as adding a product to the cart, there should be an immediate response. Instead of waiting for the server-side confirmation, the instant response must get flashed that ‘the product is added to the cart’.

Furthermore, yield to the main thread before JavaScript blocks it (by ‘run to completion’) until each code has been executed. To do this, manually create a breakpoint wherein browser will update the layout by ‘yielding to the main thread’.

Wrap the parts of the code into setTimeout()

const formfeedbackEl = document.getElementById("formfeedback");
const formEl = document.getElementById("form");
formEl.addEventListener("submit", (evt) => {

  formfeedbackEl.innerText = "Submitting form ... please hold on";
  let headers = new Headers({ Accept: "application/json" });
  let formData = new FormData(formEl);
  fetch("/form-endpoint", { method: "POST", headers, body: formData })
    .then(function (response) {
      return response.json();
    .then(function (jsonData) {
      formfeedbackEl.innerText = jsonData.message;
  setTimeout(other_code_that_needs_to_run(), 0);

3. Keep all elements simple to minimize presentation delay!

After the interaction, badly coded environments re-render too much content, which becomes a profound reason behind presentation delay. Thus, it is important to make re-rendering easier.

  1. Try to keep the DOM (Document Object Module) simple and small thereby a browser will render the page easily. The fewer DOM elements, the faster rendering will be done than pages with complicated DOM nodes.
  2. Content visibility can be used to speed up the rendering of visible parts of a web page by delaying the rendering of off-screen content.

Wrapping up

So, web pages need to be set for this new metric to maintain their performance. However, other metrics of Core Web Vitals are equally important. Unless you pay attention to all of them (CLS, LCP, and FID), website performance will not be at par.

The importance and need of Core Web Vitals are crucial for organizations if they are aiming to enhance user experience and search engine ranking. Thus, optimize websites for better Core Web Vital scores.

Elevate user experiences and amplify conversions by optimizing core web vitals. Our experts collaborate to perfect Google page experiences, while our adaptable SEO services ensure prominent SERP rankings. Contact us at or request a free quote now.

Request Free Quote

This question is for testing whether or not you are a human visitor and to prevent automated spam submissions.
3 + 2 =
Solve this simple math problem and enter the result. E.g. for 1+3, enter 4.