Pages, views, and navigations in the New RUM Experience

• Latest Dynatrace
• Explanation
• Published Nov 27, 2025
• Preview

The New RUM Experience uses the concepts of pages, views, and navigations to give you detailed visibility into your application's behavior and help you elevate performance—whether you're working with a traditional website or a Single Page Application (SPA).

Pages

In the New RUM Experience, the concept of a page aligns with the browser's technical definition: It represents the document request, the displayed content, and all events that occur during its lifecycle—ending with the next document request.

For a traditional website, pages let you analyze each full-page navigation. For an SPA, pages capture the initial load when the user first opens the application, while views provide the complete picture as content changes dynamically.

Pages and page instances

Each visit to a website generates a page instance. The data captured is aggregated into a page summary event, which is identifiable by its page.instance_id.

Pages group all visits into one aggregated entry. To analyze the same page over all visits, page instances are grouped under page.name. The page.name attribute is designed to filter out dynamic URL parts for better grouping. It's derived from page.detected_name, which the RUM JavaScript bases on the URL.

The page load of each new page instance is captured as an event with the following three characteristics:

Google Web Vitals

Google Web Vitals are critical for understanding the user experience on a page. These metrics are captured with every page summary event. For details, see Web vitals attributes in the Semantic Dictionary. As Google's official Web Vitals specification is page-based, the built-in Web Vitals metrics in the New RUM Experience are based on the values in page summaries, even though Web Vitals are also captured in view summary events.

Example DQL query

The following DQL query retrieves the 75th percentile for the Largest Contentful Paint (LCP) Web Vital by page.

fetch user.events
| filter characteristics.has_page_summary
| filter isNotNull(web_vitals.largest_contentful_paint)
| summarize {
    percentile(web_vitals.largest_contentful_paint, 75)
  }, alias:page_LCP, by:{ page.name }
| sort page_LCP desc

Views

On a traditional website, every navigation triggers a full-page load, which makes it straightforward to track individual pages and their Web Vitals, providing the data needed to optimize the site. SPAs, however, work differently. They typically involve a single initial page load and then update content dynamically without reloading the entire page. This requires a different approach to segmenting and aggregating data to optimize specific parts of the application.

The New RUM Experience automatically interprets soft navigations (also called route changes) as changes to a new view. A view refers to the content displayed and all events occurring between two navigations. This concept provides meaningful performance insights for SPAs.

Views and view instances

Each navigation creates a new view instance, whether it's a soft navigation or a hard navigation involving a full-page load. The start of a new page instance always marks the start of a new view instance.

Captured data for a view instance is aggregated into a view summary event, identified by its view.instance_id.

Views group all visits into a single aggregated entry. To analyze the same view across multiple visits, view instances are grouped under the view.name. This attribute is designed to filter out dynamic parts of the URL for better grouping. It's derived from view.detected_name, which the RUM JavaScript bases on the URL.

During the page's lifespan, the view.sequence_number attribute is incremented with every navigation to a new view.

Conceptually, if a page loads and no soft navigation occurs before the next page load, the values in the view summary event and the page summary event are identical. When one or more soft navigations occur during the lifecycle of a page instance, the values in the page and view summaries diverge.

Example of page and view instances

The following diagram shows the page and view instances created during a website visit that involves both hard and soft navigations.

Google Web Vitals

The New RUM Experience doesn’t just capture Web Vitals for pages, it also captures them for views within a page. This is especially important for SPAs.

For example, imagine a page that displays an image gallery. The initial view shows an overview with small thumbnails. When the user navigates to the detail view of an image, a new view starts.

Example DQL query

The following query retrieves the 75th percentile for LCP by view.

fetch user.events
| filter characteristics.has_view_summary
| filter isNotNull(web_vitals.largest_contentful_paint)
| summarize {
    percentile(web_vitals.largest_contentful_paint, 75)
  }, alias:view_LCP, by:{ view.name }
| sort view_LCP desc

Navigations

Navigation events are reported during view changes and/or page changes. How they are reported depends on whether the navigation is hard (full page load) or soft (SPA route change).

Hard navigations

For a hard navigation or full page load, the navigation event includes the document request and has, among others, the following characteristics:

These events also contain full W3C Navigation Timing data from supporting browsers.

Soft navigations

For a soft navigation, a standalone navigation event is reported with the characteristic characteristics.has_navigation. It includes basic information about the navigation, such as:

Example of hard and soft navigations

The diagram below illustrates how view and page summaries are reported during hard and soft navigations, along with the corresponding navigation events.

Example DQL query

The following DQL query retrieves the amount of hard and soft navigations.

fetch user.events
| filter characteristics.has_navigation
| summarize count(), by: navigation.type