Study guide

15.1 Notebooks: Section-Based Investigation & Shareable Analysis

Dynatrace Certified Associate Exam

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Platform Overview, Deployment Models & Architecture

1.1 Dynatrace Platform Capabilities, Web UI Navigation & the Dynatrace Hub 1.2 SaaS vs. Dynatrace Managed Architecture & Security 1.3 Core Telemetry Components: OneAgent, ActiveGate & Grail Lakehouse 1.4 Licensing Models: Dynatrace Platform Subscription (DPS) & Davis Data Units (DDUs)

2 Chapter 2: ActiveGate Architecture & Network Topologies

2.1 ActiveGate Types: Environment vs. Cluster ActiveGates 2.2 ActiveGate Capabilities: Proxying, Private Synthetic, Cloud Integrations & Extensions 2.3 Network Zones, Multi-DC Routing & Firewall Traversal

3 Chapter 3: OneAgent Deployment, Configuration & Management

3.1 OneAgent Architecture, Components & Automatic Injection 3.2 Host Installation on Linux, Windows & Containerized Hosts 3.3 Cloud-Native Deployment: Dynatrace Operator on Kubernetes & OpenShift 3.4 Kubernetes Observability: Clusters, Nodes, Namespaces, Workloads & Events

4 Chapter 4: Monitoring Modes, Process Groups & Infrastructure Observability

4.1 Monitoring Modes: Full-Stack vs. Infrastructure-Only vs. Discovery 4.2 Process Groups, Process Instances & Custom Process Group Detection Rules 4.3 Host Groups, Host Naming Rules & Environmental Metadata Extraction 4.4 Infrastructure & Operations: Host Health, Disk, Network & Availability Analysis 4.5 Database Observability: The Databases App, Connection Pools & Storage Latency

5 Chapter 5: Smartscape Topology & Service Flow

5.1 The 5-Layer Smartscape Topology: Datacenter to Application 5.2 Service Detection: Web Services, Background Tasks & Custom Services 5.3 Service Flow, Backtrace Analysis & Horizontal/Vertical Dependency Mapping

6 Chapter 6: PurePath Distributed Tracing & Code-Level Diagnostics

6.1 PurePath Architecture, Distributed Tracing & Request Context Propagation 6.2 Method Hotspots, CPU Profiling & Memory Allocation Thread Analysis 6.3 Database Service Diagnostics, Slow Queries & Exception Analysis

7 Chapter 7: Davis AI Engine, Baselining & Causation

7.1 Davis Deterministic Causation Engine vs. Pure Correlation 7.2 Automated Dynamic Baselining, Percentiles & Traffic Seasonality 7.3 Event Ingestion, Event Types & Event Hierarchy in Problem Evolution

8 Chapter 8: Problem Lifecycle, Root Cause Analysis & Alerting

8.1 Problem Lifecycle, Severity Categories & Root Cause Cards 8.2 Alerting Profiles, Delay Filters & Management Zone Routing 8.3 Problem Notification Integrations: Webhooks, Slack, ServiceNow & ITSM

9 Chapter 9: Digital Experience Monitoring: Synthetic Monitoring

9.1 Synthetic Monitors: HTTP, Single-Step Browser & Multi-Step Clickpaths 9.2 Private Synthetic Locations, ActiveGate Engines & Credential Vault 9.3 Outage Detection, Performance Baselining & Maintenance Suppression

10 Chapter 10: Digital Experience Monitoring: Real User Monitoring (RUM)

10.1 RUM Architecture, OneAgent Script Injection & Mobile/OpenKit Telemetry 10.2 User Actions: Load vs. XHR/Fetch Actions, Visually Complete & Speed Index 10.3 Apdex Performance Ratings, User Sessions & Session Replay Masking

11 Chapter 11: Log Management and Analytics on Grail with DQL

11.1 Log Management on Grail: Storage, Ingestion Pipelines & Log Masking 11.2 Dynatrace Query Language (DQL): Fetch, Filter, Fields & String Operations 11.3 DQL Aggregations: Summarize, MakeTimeseries, Sorting & Visualizations

12 Chapter 12: Platform Governance, OpenTelemetry & Automation

12.1 Management Zones: Scoping Observability, Dashboards & Access Control 12.2 Tagging Strategies: Automated Rule-Based Tags, Manual Tags & AWS/K8s Metadata 12.3 OpenTelemetry Ingestion, OpenPipeline & Dynatrace Workflows Automation

13 Chapter 13: Cloud Integrations & Agentless Infrastructure Ingestion

13.1 AWS, Azure & Google Cloud Integrations 13.2 VMware vSphere, Extensions & Other Agentless Ingestion Paths

14 Chapter 14: Business Analytics & Business Events

14.1 Business Events: Capture, Ingestion & the bizevents Grail Table 14.2 Business Analytics: Connecting Performance to Revenue, Conversion & KPIs

15 Chapter 15: Notebooks, Dashboards & Data Visualization

15.1 Notebooks: Section-Based Investigation & Shareable Analysis 15.2 Dashboards: Tiles, Variables, Segments & Continuous Monitoring 15.3 Choosing Visualizations: Data Explorer, Chart Types & Metric Selection

16 Chapter 16: Reporting, Metrics & User Behavior Analysis

16.1 Metrics on Grail: Built-in Metrics, Granularity & Retention 16.2 Dashboard Reports, Subscriptions & Exporting Data via APIs 16.3 User Behavior Analysis: Bounce Rate, Landing & Exit Pages, Conversion Goals 16.4 Session Segmentation, User Journeys & Funnel Drop-Off Analysis

17 Chapter 17: Security, Vulnerability Analytics & Application Protection

17.1 Platform Security: Data Privacy, Encryption & Access Control 17.2 Third-Party Vulnerabilities, the Davis Security Score & Security Advisor 17.3 Code-Level Vulnerabilities, Attacks & Runtime Application Protection 17.4 Security Investigator, Notifications & the Remediation Workflow

15.1 Notebooks: Section-Based Investigation & Shareable Analysis

Key Takeaways Explain This Topic AI

Dashboards is a separately scored Associate exam topic, and the official learning path devotes a full lesson to Notebooks and Dashboards together.

Notebooks are organized into sections — DQL query sections, code sections powered by Dynatrace functions, and markdown sections for narrative.

Notebooks are the investigation and storytelling surface: the analytical narrative is stored inside the notebook itself, whereas a dashboard is something you view.

The standard incident workflow is to investigate in a Notebook, then promote the queries that proved useful into a Dashboard for ongoing monitoring.

Notebooks can combine logs, metrics, traces, business events, and markdown commentary in one document because every data type is queryable with DQL against Grail.

Last updated: September 2026

Dashboards is one of the twelve scored topics on the Dynatrace Associate exam score report, and the official learning path pairs it with Notebooks in a single lesson: "Notebooks enable custom exploration and visualization of observability data, integrating external sources and predictive analytics within interactive documents. Dashboards provide continuous monitoring and visualizations of key performance metrics."

The exam tests whether you can pick the right one for a given task, so start with the distinction and then learn each tool.

The Core Distinction

Data in a notebook is stored within the notebook; a dashboard is something you view.

That one sentence carries most of the exam weight. A Notebook is a document — it holds the queries, the results, and your written reasoning, so it can be handed to somebody who was not in the incident call. A Dashboard is a live view — it re-queries continuously and shows current state, but it does not carry an argument.

  • Notebook Dashboard
  • Organized into Sections Tiles
  • Primary purpose Investigation, root-cause storytelling, analysis Continuous, real-time monitoring
  • Reading order Top to bottom, like a document At-a-glance, all tiles simultaneously
  • Contains narrative Yes — markdown sections between queries Only via markdown tiles
  • Typical audience Analyst, incident reviewer, stakeholder briefing NOC, on-call, service owner, executive wall
  • Typical lifespan One investigation Ongoing
  • Notebook Sections

A notebook is a sequence of sections , and there are three types you must know:

Query section

The query section consists of a query input where you write a DQL query . Results render as a table or chart, and the visualization can be changed without altering the query. This is where the analysis happens: fetch logs, from: now() - 2h

  • | filter k8s.namespace.name == "checkout" and loglevel == "ERROR"
  • | summarize errors = count(), by: { k8s.workload.name }
  • | sort errors desc
  • Code section

The code section enables you to fetch data for your notebook using Dynatrace functions . This is how a notebook reaches beyond Grail — calling an external API, applying a transformation Grail does not express natively, or blending platform data with a third-party source.

Markdown section

A markdown section can be anything from a minor note about something on the notebook to a whole page of formatted information with links and pictures . This is what turns a pile of queries into an artifact somebody else can read: the hypothesis, what was ruled out, and the conclusion.

The Canonical Investigation Flow

The learning path's Playground exercise is deliberately this shape, and exam scenarios mirror it:

State the question in a markdown section. "Checkout latency doubled at 14:05. Which layer?"

Query the service to confirm and scope the degradation.

Query the infrastructure to test the host hypothesis — and write down that it was eliminated.

Query the logs for the affected workload in the same window.

Query business events to quantify what it cost (Chapter 14).

Conclude in markdown, then share the notebook.

Because every one of those steps is DQL against Grail, a single document spans logs, metrics, traces, and business events with no tool switching. That cross-data-type capability in one document is a recurring exam theme.

Notebooks and Predictive Analysis

Notebooks integrate external sources and predictive analytics , which is how capacity questions are answered inside the platform rather than in a spreadsheet: fit a trend over historical usage and project when a volume, licence pool, or cluster reaches a threshold. The exam does not require you to write the forecast, only to know that a Notebook — not a dashboard tile — is where analysis of that kind belongs.

Promotion to a Dashboard

The two tools are stages of one workflow, not competitors. The official call to action is explicit: create a Notebook with DQL and markdown tiles, then do the same in a Dashboard and consider how the apps differ.

The operational rule:

Investigate in a Notebook. Once a query has proven it detects a real, recurring condition, promote it to a Dashboard tile so it is watched continuously.

A dashboard assembled from queries that were never validated during a real investigation is how organizations end up with wall displays nobody trusts. Exam answers that propose building a dashboard first to explore an unfamiliar problem are working backwards.

Access, Sharing, and Governance

Notebooks and dashboards are documents with sharing controls, and they are managed through the Document API for programmatic creation and version control. Two governance points appear in scenarios:

Management zones and segments (Chapter 12) constrain what a viewer can see, so the same shared notebook can legitimately show different results to different readers.

Sharing a notebook does not grant the recipient permission to data they could not otherwise query. Permissions are evaluated on the reader, not baked into the document.

Loading diagram... Notebook Sections and the Investigate-Then-Promote Workflow