Try it free

Customize Experience Score with OpenPipeline

  • Latest Dynatrace
  • How-to guide
  • Published Nov 03, 2026

The Experience Score rates your users' experience based on how Dynatrace classifies user events. By default, it scores user actions by their duration. Add OpenPipeline processors to align the score with how your team defines a good experience—for example, to give business-critical user actions a higher weight, classify web user actions by Core Web Vitals, or count crashes as frustrating.

Prerequisites

  • You have permission to edit the OpenPipeline configuration for user events. For details, see Owner-based access control in OpenPipeline.
  • You're familiar with how the Experience Score is calculated.

Add an Experience Score processor

The score formula is fixed, but you control everything that feeds into it through OpenPipeline processors:

  • Which events are scored: Only events with an experience.level field count toward the score.
  • How events are classified: The value of experience.level, either satisfied, tolerating, or frustrated.
  • How much each event counts: The value of experience.weight.

The default classification comes from the Experience Score calculation pre-processing in the built-in RUM Agent ingest source. Because ingest source pre-processing runs before data is routed to a pipeline, any processor that you add to a user events pipeline overrides the experience.level or experience.weight set during pre-processing. Events that your processors don't match keep their default classification.

You can't edit or duplicate the Experience Score calculation pre-processing. To change the classification, set up your own processor in a user events pipeline. Within a pipeline, processors run in order, so a processor further down the pipeline overrides the values that an earlier processor set for the same event.

To add a processor

  1. Go to Settings Settings > Process and contextualize > OpenPipeline > User events > Pipelines.

  2. Select the pipeline that processes your RUM events, or create a new one by selecting Pipeline and entering a name.

  3. Go to Processing > Add > DQL.

  4. Define the processor:

    • Name: A descriptive name, for example, Weight checkout user actions.
    • Matching condition: A filter for the events that you want to classify.
    • DQL processor definition: A fieldsAdd statement that sets experience.level, experience.weight, or both.

    For ready-to-use definitions, see Examples.

  5. Select Save.

To verify the result, run the following query in Notebooks Notebooks after new user events have been ingested. The query shows how many events each combination of level and weight applies to.

fetch user.events
| filter isNotNull(experience.level)
//| filter frontend.name == "FRONTEND-NAME" // Optional: filter to a specific frontend
| summarize events = count(), by: {experience.level, experience.weight}

Processor changes apply only to user events ingested after you save. Existing events and sessions keep their classification.

Examples

Give business-critical user actions a higher weight

By default, every user action has the same experience.weight, so a slow product listing and a slow payment step lower the score equally. To make a frustrating experience on a payment page lower the score more than elsewhere, give the related user actions a higher weight.

  • Matching condition:

    characteristics.has_user_action == true and matchesValue(page.url.path, "*/checkout*")
  • DQL processor definition:

    fieldsAdd experience.weight = 3

This processor only overrides the weight. The duration-based experience.level from the Experience Score calculation pre-processing stays as it is.

Classify web user actions by Core Web Vitals

Duration alone is a coarse signal. For web frontends, you can classify user actions by Core Web Vitals instead, so that a page that loads quickly but shifts its layout or reacts slowly to input still counts as a poor experience.

  • Matching condition:

    characteristics.has_user_action == true
    and isNotNull(web_vitals.largest_contentful_paint)
    and isNotNull(web_vitals.cumulative_layout_shift)
    and isNotNull(web_vitals.interaction_to_next_paint)
  • DQL processor definition:

    fieldsAdd experience.level = if(
    web_vitals.largest_contentful_paint <= 2500000000
    and web_vitals.cumulative_layout_shift <= 0.1
    and web_vitals.interaction_to_next_paint <= 200000000,
    "satisfied",
    else: if(
    web_vitals.largest_contentful_paint <= 4000000000
    and web_vitals.cumulative_layout_shift <= 0.25
    and web_vitals.interaction_to_next_paint <= 500000000,
    "tolerating",
    else: "frustrated"))

The matching condition requires all three Core Web Vitals, because the processor compares all of them. User actions that lack any of these values keep their default duration-based classification.

Web Vitals durations are reported in nanoseconds—for example, 2500000000 is 2.5 seconds. Adjust the thresholds to the targets that fit your frontend.

Include crashes in the score

A crash terminates the application, so it's one of the most frustrating experiences a user can have. To include crashes in the score, add a processor that classifies crash events as frustrating and gives them a high weight.

  • Matching condition:

    characteristics.has_crash == true
  • DQL processor definition:

    fieldsAdd experience.level = "frustrated",
    experience.weight = 50

Each crash then counts as an additional scored event, next to the user actions of the same session and frontend. The high weight makes crashes dominate the score even when they're rare.

Classify user actions with server errors as frustrating

By default, a user action is classified only by its duration, so a fast user action whose requests fail still counts as satisfied. To treat user actions with HTTP 5xx errors as frustrating on web and mobile frontends, regardless of their duration, add a processor that reclassifies them.

  • Matching condition:

    characteristics.has_user_action == true and error.http_5xx_count > 0
  • DQL processor definition:

    fieldsAdd experience.level = "frustrated",
    experience.weight = 4

The weight of 4 makes a user action with a server error lower the score more than an ordinary slow user action, which keeps a weight of 1.

Analyze the Experience Score

Analyze the Experience Score per frontend to spot regressions over time, or per session to find the sessions worth investigating. Run the queries below in Notebooks Notebooks.

To chart the Experience Score of each frontend over time, derive it from the dt.frontend.experience.weight metric. Add a by dimension such as browser.name, device.type, or geo.country.iso_code to find out which user segments have a worse experience.

timeseries {
satisfied = sum(dt.frontend.experience.weight, filter: experience.level == "satisfied"),
tolerating = sum(dt.frontend.experience.weight, filter: experience.level == "tolerating"),
total = sum(dt.frontend.experience.weight)
}, by: {frontend.name}
//| filter frontend.name == "FRONTEND-NAME" // Optional: filter to a specific frontend
| fieldsAdd experience_score = (satisfied[] + tolerating[] / 2) / total[]
| fieldsRemove satisfied, tolerating, total

To find sessions below a score threshold, query experience.score on user sessions. A threshold covers several adjacent bands at once—for example, experience.score < 0.7 returns all sessions in the poor and unacceptable bands.

fetch user.sessions
//| filter in("FRONTEND-NAME", frontend.name) // Optional: filter to sessions that include a specific frontend
| filter experience.score < 0.7
| fields start_time, dt.rum.session.id, frontend.name, experience.score, experience.score.band
| sort experience.score asc

To find sessions in a specific band, filter by experience.score.band. The band values are lowercase: excellent, good, fair, poor, and unacceptable.

fetch user.sessions
//| filter in("FRONTEND-NAME", frontend.name) // Optional: filter to sessions that include a specific frontend
| filter experience.score.band == "unacceptable"
| fields start_time, dt.rum.session.id, frontend.name, experience.score
| sort experience.score asc

To compare how sessions are distributed across the Experience Score bands, use the following example.

fetch user.sessions
//| filter in("FRONTEND-NAME", frontend.name) // Optional: filter to sessions that include a specific frontend
| filter isNotNull(experience.score.band)
| summarize sessions = count(), by: {experience.score.band}

To filter sessions by Experience Score without DQL, use Users & Sessions Users & Sessions.

Related topics

  • Built-in RUM data enrichments
  • Built-in RUM metrics
  • Users & Sessions
  • OpenPipeline
Related tags
Digital ExperienceOpenPipelineOpenPipeline