iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
A blank INP result in a lab speed test usually means the test did not produce a qualifying click, tap, or keyboard interaction—or that the Event Timing observer filtered out short events. Scrolling and hovering do not count as INP interactions. To diagnose a reproduced interaction, check the test journey and observer threshold; to understand how the page responds to real users, use field measurement.
Why does INP show no data in a lab test?
Interaction to Next Paint (INP) measures responsiveness for click, tap, and keyboard interactions during a page visit. It considers the latency from an interaction through the next paint and reports one of the slowest interactions, rather than averaging every interaction. Google’s INP guidance notes that a page may have no INP value when no qualifying interaction occurs.
The test never clicked, tapped, or pressed a key
A page-load-only run may collect loading metrics without exercising any controls. If the automated journey does not click, tap, or use the keyboard, it has no qualifying interaction from which to calculate INP. Add a realistic interaction to the test journey, such as opening a menu or submitting a form, then inspect that interaction’s trace.
Recommended Free Tools
The test used a gesture INP does not measure
Scrolling and hovering are not the click, tap, or keyboard interactions used for INP. A run that only scrolls or hovers can therefore have no INP even though the page was active.
#1 Best Overall
The browser did not perform scripted interactions
A bot or headless-browser run that only loads the page may not interact with it. Verify that the automation actually dispatches user-like clicks, taps, or key presses and that those actions reach the intended controls.
The observer filtered out short event entries
An empty PerformanceObserver result does not prove that no interaction happened. By default, Event Timing’s event entries use a 104-millisecond duration threshold, so shorter entries are not reported to that observer. Google’s Event Timing API guidance documents 16 milliseconds as the minimum configurable threshold. Lowering the threshold can expose shorter entries for diagnosis, but it does not turn every raw event entry into an INP value.
Rank #2
How can I check the Event Timing API observer?
Observe event entries with a lower threshold when you need to inspect shorter interactions. The INP guidance also recommends observing first-input, which can be observed even when it is shorter than the event threshold.
const observer = new PerformanceObserver((list) => {
for (const entry of list.getEntries()) {
const inputDelay = entry.processingStart - entry.startTime;
const processingTime = entry.processingEnd - entry.processingStart;
const presentationDelay = entry.startTime + entry.duration - entry.processingEnd;
console.log({
name: entry.name,
duration: entry.duration,
inputDelay,
processingTime,
presentationDelay,
target: entry.target,
});
}
});
observer.observe({ type: 'event', buffered: true, durationThreshold: 16 });
observer.observe({ type: 'first-input', buffered: true });Use this as diagnostic instrumentation, not as a replacement for the browser’s INP calculation. Check browser support and the current API guidance for the environment where you run it.
What does PerformanceEventTiming.duration include?
The Event Timing API describes an event’s timing through the next frame, not just the time spent inside its event handlers. Google Chrome for Developers defines duration as the time from when the browser receives the event until it can paint the next frame after synchronous code initiated by the event handlers finishes. The documented duration is rounded to 8 milliseconds for security reasons.
startTime: when the browser receives the event.processingStart: when the browser can begin processing event handlers.processingEnd: when synchronous code initiated from event handlers finishes.duration: elapsed time from event receipt until the browser can paint the next frame after that synchronous work.
You can use the timestamps to estimate the phases:
- Input delay:
processingStart - startTime. - Event-handler processing:
processingEnd - processingStart. - Presentation delay:
startTime + duration - processingEnd.
These calculations help distinguish waiting before handlers run from time spent in handler code or waiting for a frame. INP groups related event handlers from the same logical interaction, so a single raw entry’s duration is not necessarily the page’s INP.
Rank #4
How should I use lab and field INP measurements?
Lab and field data answer different questions. A lab run is useful for reproducing and inspecting a deliberately exercised interaction. Field data is the recommended way to understand INP across the interactions real users perform. Google’s guidance on diagnosing slow interactions in the lab recommends considering CPU throttling or a lower- to mid-tier Android device to make long tasks easier to expose.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →| Measurement context | What it captures | Best use | Limitation |
|---|---|---|---|
| Lab | Interactions deliberately exercised in a controlled test. | Reproducing a known slow interaction and inspecting its trace timings. | No qualifying scripted interaction can leave INP absent; findings depend on the test journey. |
| Field | Actual user interactions; real-user monitoring (RUM) can include the responsible interaction, its type, timing, and page-lifecycle context. | Assessing responsiveness across real visits and interaction patterns. | Requires field data collection and interpretation; users’ interaction mix varies. |
For field collection, Google’s field guidance describes the web-vitals library. Version 4 added deeper INP phase breakdowns and Long Animation Frames API data that can help attribute work to scripts, including third-party contributions. Check the library’s current version and browser support before implementing it.
Best Value
- Used Book in Good Condition
How does INP differ from FID?
INP became a Core Web Vital on March 12, 2024, replacing First Input Delay (FID) as the responsiveness metric. FID measured only input delay for the first interaction. INP considers interaction latency through the next paint over the page lifecycle, making a lab test’s interaction journey especially important. Google’s announcement describes the change.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
