Website Monitoring with OpenTelemetry and Dash0

Website Monitoring with Dash0

End-to-end visibility into real user experience using OpenTelemetry

Website monitoring is the most direct way to understand how real people experience your product in production, on real devices, across real networks, with real browsing habits.

This guide describes how Dash0 Website Monitoring works, how it is instrumented, and how the resulting data can be used across frontend, backend, SRE, product, and marketing workflows. Each section is accompanied by a short video that demonstrates the concepts in practice.

Who this guide is for

This guide is intended for teams responsible for the behavior, performance, and reliability of web applications in production:

• Frontend engineers instrumenting client-side applications and optimizing real user performance.
• Backend engineers correlating frontend activity with distributed traces.
• SRE and platform teams managing observability, reliability, and cost.
• Product and marketing teams analyzing user journeys, drop-offs, and conversion behavior.

1. What Is Website Monitoring?

Website monitoring, often called Real User Monitoring (RUM), answers a simple question: what did users actually experience?

Instead of synthetic tests or averaged metrics, Website Monitoring operates on real user sessions across real browsers, devices, locations, and navigation patterns. Performance metrics, errors, and interactions are captured in the context of individual sessions, making it possible to understand impact and root cause directly.

Dash0 Website Monitoring is built on OpenTelemetry standards:

• Web SDK instruments browser APIs (Navigation Timing, Resource Timing, Performance Observer)
• Telemetry data follows OpenTelemetry semantic conventions
• OTLP protocol sends spans to Dash0's ingestion endpoint
• Correlation via trace context propagation links frontend and backend spans

2. Installation & Initialization

Dash0 Website Monitoring is designed to be simple to deploy and safe to run in production environments. Instrumentation is performed by installing the Dash0 Web SDK and initializing it once at application startup.

The SDK is fully open source and built on OpenTelemetry. This provides a vendor-neutral data model and allows frontend telemetry to integrate cleanly with existing observability infrastructure.

Detailed setup instructions and code examples are available in the documentation.

Once deployed, telemetry begins flowing automatically. Sessions, page views, and spans become visible in the Dash0 Website Monitoring interface in near real time, allowing teams to verify instrumentation immediately and start analyzing real user behavior.

3. Core Web Vitals & Real Performance

Dash0 automatically captures Core Web Vitals for real user sessions:

• Largest Contentful Paint (LCP): Time to render the largest visible element.
• Interaction to Next Paint (INP): Responsiveness to user interactions.
• Cumulative Layout Shift (CLS): Visual stability during page load.

These metrics are collected per session and tagged with contextual attributes such as browser, operating system, device type, geographic location, page URL, and referrer.

Rather than focusing on averages, Dash0 emphasizes percentile-based analysis, such as P75. Percentiles highlight performance issues affecting slower users while avoiding skew from extreme outliers. Google uses the 75th percentile of Web Vitals as a ranking signal, making P75 especially relevant for real-world user experience and SEO. From an aggregated metric, it is possible to drill directly into the individual sessions that contributed to poor scores and inspect detailed timing information.

4. Sessions, Tabs and User Journey Analysis

Users do not navigate applications in linear paths. They open multiple tabs, switch between them, partially read content, encounter errors, and continue browsing.

Dash0 captures complete user sessions, including:

• Multiple page views within a session
• Browser tab creation and tab visibility changes
• Navigation timing for each page load
• Errors and exceptions in context

For each page view, waterfall timelines show how time is spent across document loading, resource fetching, backend requests, and user interactions. This makes it possible to understand not only that a page was slow or unstable, but why.

5. Frontend-to-Backend Correlation

Website Monitoring in Dash0 extends beyond the browser. Frontend spans are correlated with backend distributed traces using trace context propagation.

This enables workflows such as:

• Identifying which backend requests were triggered by a specific user session
• Understanding where latency originates within a distributed system
• Navigating from a frontend session directly to the backend trace it produced
• Navigating from a backend trace back to the user session that triggered it

Trace waterfalls provide a breakdown of time spent across services, helping teams distinguish frontend delays from backend bottlenecks.

6. Product & Marketing Use Cases

Website Monitoring data can also be used beyond engineering workflows. Product and marketing teams can analyze real user behavior using the same underlying telemetry.

Common use cases include:

• Identifying top visited pages and traffic sources
• Understanding multi-step funnels and drop-offs using page flow views
• Analyzing behavior across geographies, devices, and platforms
• Investigating errors in the context of user journeys

Because Dash0 follows OpenTelemetry semantic conventions, attributes such as user agent and geography are structured and standardized, enabling consistent analysis across dimensions.

7. Privacy & Compliance

Dash0 is privacy-first by default. Users are anonymous unless you explicitly identify them, and you control exactly what data is collected. With filtering, redaction, and sampling, teams can meet compliance requirements while still retaining the data needed to understand performance and behavior in production.

Compliance Considerations

• GDPR: Anonymous sessions are not considered personal data. User identification requires consent and a data processing agreement.
• CCPA: If you identify users, provide mechanisms for data access and deletion requests.
• Data residency: Dash0 supports region-specific ingestion endpoints.

8. Pricing & Cost Management

Dash0 uses event-based pricing rather than session-based pricing.

An event represents an instrumented unit of activity, such as a page load, interaction, resource request, or error. Pricing therefore scales with actual telemetry volume rather than session duration.

This avoids cost inflation caused by long-lived or idle sessions and allows teams to control data volume through sampling and filtering while retaining full visibility into errors and performance issues.

9. Summary

Dash0 Website Monitoring provides end-to-end visibility into how users experience your application in production. Using a standards-based OpenTelemetry Web SDK, it captures real user performance data, including Core Web Vitals, navigation timing, errors, and interactions, without relying on synthetic tests or averages.

Sessions, page flows, and waterfall timelines make it possible to understand performance and errors in context, while trace correlation links frontend activity directly to backend distributed traces. This shared view supports frontend engineers, backend engineers, SREs, and product teams with the same underlying data.

By combining real user behavior, performance metrics, and backend execution in a single system, Dash0 reduces time to resolution and enables more informed decisions about user experience, reliability, and conversion. Instead of guessing where problems originate, teams can see exactly what happened, who was affected, and where to focus next.

Get started with Website Monitoring today!