Study guide
3.4 Troubleshooting Canvas and Model-Driven Apps with Monitor and Browser Debugging Tools
Microsoft Power Platform Developer Associate PL-400
Track your progress as you read
Finished sections get a check mark.
1 Introduction, Exam Overview & Developer Toolchain
0.1 PL-400 Exam Facts 0.2 Audience Profile & Required Developer Skills 0.3 The Power Platform Developer Toolchain 0.4 Extension-Point Map & AI in the Developer Workflow
2 Create a Technical Design
1.1 Analyzing Technical Architecture and Choosing Out-of-the-Box vs. Custom Solutions 1.2 Designing Authentication, Authorization, and Security Architecture 1.3 Deciding Where Business Logic Runs and Choosing the Right Table Type 1.4 Designing Reusable Power Apps Components and Custom Connectors 1.5 Designing Dataverse Code Components, Automations, and Integrations
3 Build Power Platform Solutions
2.1 Managing Power Platform Environments for Development 2.2 Dataverse Security Roles for Code Components, Least Privilege & Troubleshooting Operational Security 2.3 Solutions, Managing Dependencies & Solution Layers 2.4 Environment Variables & Connection References 2.5 Power Platform Pipelines & CI/CD with Power Platform Build Tools
4 Implement Power Apps Improvements
3.1 Complex Power Fx Formulas and Functions 3.2 Building Reusable Canvas Component Libraries 3.3 Invoking Power Automate Cloud Flows from a Canvas App 3.4 Troubleshooting Canvas and Model-Driven Apps with Monitor and Browser Debugging Tools 3.5 Optimizing Canvas and Model-Driven App Performance
5 Extend the User Experience
4.1 The Client API Object Model & JavaScript Form Scripting 4.2 Event Handler Registration & Navigation to Custom Pages via the Client API 4.3 Client Scripting Against the Dataverse Web API; Command Bar & Buttons with Power Fx and JavaScript 4.4 PCF Fundamentals: The Component Manifest & Lifecycle Events 4.5 Implementing PCF Component Interfaces; Device, Utility & Web API Features 4.6 Packaging, Deploying & Consuming a PCF Component
6 Extend the Platform: Dataverse Plug-ins & Custom APIs
5.1 Plug-in Fundamentals & the Event Execution Pipeline Stages 5.2 Execution Context & Implementing Business Logic in Plug-ins 5.3 Pre/Post Images & Organization Service Operations in Plug-ins 5.4 Registering Plug-ins with the Plug-in Registration Tool & Optimizing Plug-in Performance 5.5 Custom API Messages & Plug-ins That Implement a Custom API 5.6 Configuring Dataverse Business Events
7 Extend the Platform: Custom Connectors
6.1 Open API Definitions: Building and Extending a Custom Connector 6.2 Authentication and Policy Templates for Custom Connectors 6.3 Importing Definitions and Creating Connectors for Azure Services 6.4 Azure Functions in Custom Connectors and Data Transformation
8 Extend the Platform: Platform APIs & Azure Functions
7.1 Dataverse Web API Operations & OAuth Authentication 7.2 Organization Service Operations, Concurrency, Transactions & Bulk Operations 7.3 Service Protection API Limits & Retry Policies 7.4 Azure Functions for Long-Running, Scheduled & Event-Driven Workloads 7.5 Authenticating to Power Platform with Managed Identities
9 Extend the Platform: Power Automate Cloud Flows
8.1 Dataverse connector triggers/actions, trigger filters & retry policies 8.2 Complex expressions & flow control with error handling 8.3 Sensitive input/output parameters & Azure Key Vault 8.4 Reusable child flows & Microsoft Entra ID service principals
10 Develop Integrations
9.1 Publishing Dataverse Events: IServiceEndpointNotificationService & the Plug-in Registration Tool 9.2 Registering Service Endpoints: Webhooks, Azure Service Bus & Event Hub 9.3 Data Synchronization with Change Tracking & Alternate Keys 9.4 Upsert-Based Synchronization with the UpsertRequest Message
11 Exam Readiness & Practice
10.1 Cross-Domain "Where Do I Implement This?" Decision Framework 10.2 Exam-Day Strategy, PL-400 Item Styles & Study Plan
3.4 Troubleshooting Canvas and Model-Driven Apps with Monitor and Browser Debugging Tools
Key Takeaways Explain This Topic AI
Monitor attaches to a live app session and streams formula evaluations, data calls, and errors in real time for both canvas and model-driven apps.
Monitor exposes delegation warnings and per-call latency inline with the control and formula that triggered them.
Browser developer tools (Console, Network, Sources) debug raw JavaScript errors in model-driven client scripts and PCF components that Monitor doesn't interpret.
The Network tab shows raw Dataverse Web API requests and responses, useful when Monitor's higher-level logging isn't specific enough.
Correlation IDs surfaced by Monitor let developers escalate server-side issues to Microsoft support without reproducing client-side steps.
Last updated: July 2026
Monitor: A Real-Time Window Into App Execution
Monitor is Power Platform's built-in diagnostic tool for observing what a canvas or model-driven app is actually doing while it runs — not just what the formula bar or form definition says it should do. It's launched from the Power Apps maker portal (an app's details page > Monitor) or directly from Studio's Preview mode, and it attaches to a live session of the app, streaming events as the tester interacts with it in real time. This is the tool the blueprint names explicitly for "troubleshoot canvas and model-driven app issues" (3d), and it's the primary developer-facing alternative to guessing why a screen is slow or a value is wrong.
What Monitor Captures
Monitor records a structured, filterable, searchable timeline of everything happening inside a session:
Formula evaluations — which control property fired, the formula that ran, and how long it took.
Network and data calls — every request to a connector, the Dataverse Web API, or a cloud flow invocation, including request and response payloads and latency.
Errors and delegation warnings — surfaced inline with the formula and control that triggered them, not just a generic error banner.
Control and screen events — OnVisible , OnSelect , navigation, and other trigger firings in sequence.
Because entries are timestamped and taggable by control, a developer can isolate exactly which data call on which screen is adding several seconds to a load — information that's effectively invisible from the Studio canvas alone. Monitor sessions can be filtered by event type and searched by control or data source name, and individual sessions can be exported for offline analysis or shared with support.
Monitor for Canvas Apps vs. Model-Driven Apps
Aspect Canvas apps Model-driven apps
Primary signal Formula timing, delegation warnings, network calls Form load events, business rule execution, script-triggered calls
Launch point App details page, or Preview mode in Studio App details page, or a running model-driven session
Typical use Diagnosing slow galleries, unnecessary re-evaluations, failed connector calls Diagnosing slow form loads, unexpected script errors, business-rule conflicts
Model-driven apps additionally expose performance data through the browser's own Diagnostics overlay, opened via a keyboard shortcut inside a running form, which reports form-load phase timing — script load, data retrieval, rendering — a level of detail Monitor complements rather than replaces for model-driven scenarios.
Browser-Based Debugging Tools
For anything Monitor doesn't surface — raw JavaScript exceptions in a model-driven form script, a PCF component's rendering logic, or a Web API call's exact request or response body — developers fall back to the browser's own developer tools (F12):
Console — surfaces uncaught JavaScript errors from Client API scripts and PCF components, plus any deliberate diagnostic logging a developer adds during development.
Network tab — shows raw HTTP requests to the Dataverse Web API ( /api/data/v9.x/... ), including headers, status codes, and JSON bodies — essential for diagnosing a failed Xrm.WebApi call that Monitor logs only at a higher level.
Sources tab — allows setting breakpoints directly inside deployed JavaScript web resources or a PCF component's bundled code, stepping through execution exactly as with any client-side web app.
Application and Storage tabs — useful for inspecting cached tokens or local storage state in offline-capable canvas apps.
Because model-driven client scripts and PCF components run as ordinary JavaScript or TypeScript in the browser, they get the full benefit of standard web debugging — unlike Power Fx, which Monitor is purpose-built to interpret since it is not standard JavaScript the browser natively understands.
Correlating and Escalating
Every traced Dataverse Web API and Organization service call surfaces a correlation ID inside Monitor. When an issue can't be resolved from Monitor or browser tools alone — a suspected platform throttling issue, an intermittent server-side error — that correlation ID is the piece of evidence to hand to Microsoft support or include in a Power Platform admin center service request, letting engineers trace the exact server-side request without needing to reproduce the client-side steps. Combining Monitor's structured event timeline with browser dev tools' raw request and response detail, and a correlation ID for anything server-side, is the complete PL-400 troubleshooting toolkit for both app types.
Choosing the Right Tool for the Symptom
A useful exam heuristic is to match the symptom to the tool rather than defaulting to one:
"A screen or form is slow, but nothing is technically broken" — start with Monitor to see which formula, data call, or form-load phase is consuming the time.
"Something throws an error message I don't understand" — check Monitor for a Power Fx or delegation-related error first; check the browser Console for a JavaScript or PCF exception if the issue is in a model-driven script or component.
"A Web API call returns unexpected data or an HTTP error code" — use the browser Network tab to inspect the exact request and response body, since Monitor's summary view may not show every field.
"The issue only happens in production, or intermittently, and can't be reproduced locally" — capture the correlation ID from Monitor and escalate through the Power Platform admin center or Microsoft support rather than continuing to guess client-side.
Treating these as a decision tree, rather than reaching for the browser console out of habit, keeps troubleshooting fast and is consistent with how the PL-400 blueprint frames this sub-topic: know which tool answers which question.