Core Web Vitals

Chrome 151 adds performance entries for SPA routes and interaction paints

The release gives developers browser timeline entries for same-document navigation and the content that appears after an interaction.

Minimal browser route panels above a timeline with mint circles and navy outlined diamond markers.

Chrome 151 adds the soft-navigation and interaction-contentful-paint performance entry types for investigating interaction-driven activity in single-page applications. The Chrome release post, dated July 28, 2026, describes browser timeline data for route changes and for new content painted after user interactions. Developers can observe these entries through PerformanceObserver.

The change addresses activity that happens after an SPA's initial document has loaded. A user can move to another route or trigger a content update without a traditional page navigation. The new entries expose those transitions and paints as distinct kinds of performance information.

A route change without a new document

In an SPA, JavaScript can move the application between views while the same browser document remains open. The Chrome announcement explains that these route transitions do not trigger a traditional browser page load. Measuring only that load therefore leaves the subsequent route transition as a separate problem for developers to examine.

The soft-navigation entry captures same-document history state changes initiated by user interactions. The user interaction and the route transition are important parts of the description: this is browser support for observing that navigation activity within the running application.

When a soft navigation occurs, Chrome establishes a new time origin. The release post says this allows subsequent performance information to be attributed to the active SPA route rather than to the original document URL. That attribution is the central practical change for teams investigating the views reached after the landing page.

For context on this distinction, see our guide to Core Web Vitals in single-page applications. The relevant question is which route the user was viewing when the performance activity occurred.

Content painted after an interaction

The interaction-contentful-paint entry addresses another part of the same user journey. It measures new contentful paints in DOM regions modified by a user interaction. The focus is the content that appears within the updated region, giving developers visibility into interaction loading latency.

The announcement explicitly includes content updates that depend on asynchronous work such as fetch() requests. An interaction can start work whose visible result arrives later; the new entry is intended to make that interaction-related loading activity observable.

These entry types describe different events. A soft navigation concerns a route change within the document. An interaction contentful paint concerns newly painted content in a region modified by an interaction. Keeping their names and purposes distinct makes the observed output easier to interpret without treating every content update as a route transition.

What the release adds

What changed Where Status
soft-navigation entries Web performance timeline Added in Chrome 151
interaction-contentful-paint entries Web performance timeline Added in Chrome 151
Observation of these entries Application PerformanceObserver Described in the release post

The official Chrome 151 feature announcement presents this work as an expansion of the performance timeline, building on established Core Web Vitals such as Largest Contentful Paint and Interaction to Next Paint. Its example observes soft navigations and uses buffering to include earlier entries from the page.

Observe both entry types

The following editorial example extends that observation pattern to both named types. Run it in the application you are investigating and exercise its user-driven routes and content updates. The support check limits registration to entry types exposed by the browser.

js
const entryTypes = [
  "soft-navigation",
  "interaction-contentful-paint",
];

for (const type of entryTypes) {
  if (!PerformanceObserver.supportedEntryTypes.includes(type)) {
    continue;
  }

  const observer = new PerformanceObserver((list) => {
    for (const entry of list.getEntries()) {
      console.log(entry.entryType, entry);
    }
  });

  observer.observe({ type, buffered: true });
}

The code logs the entry type together with the entry object, preserving the distinction between route events and content paints. Each observer is registered for its own type. The buffered option follows the pattern shown in the release post for including previous soft navigations on the page.

This is an inspection example, not a Core Web Vitals calculator. It does not aggregate results, assign a pass status or produce a CrUX report. Those operations are not part of the sample, and the release announcement does not describe a CrUX rollout.

Practical next steps for route analysis

Start with a user interaction that changes the application's route. Observe the resulting timeline output and keep the active route in view as you examine the entries. Then inspect an interaction that updates content, including an asynchronous update where the application already uses one.

Use the entry labels to separate navigation activity from content rendering. The release gives developers visibility into both, but does not make them interchangeable. That separation helps frame the investigation around the event actually being measured.

Keep locally observed entries distinct from aggregated field reporting; our field data versus lab data guide covers that broader distinction. For this release, the concrete next step is to inspect the entries Chrome exposes and relate them to the application's user-driven route changes and content updates. The announcement provides the observation mechanism, rather than a claim that those changes automatically improve performance.

Related guides