10.1 Testing Canvas Apps with Monitor

Live monitor: the maker's flight recorder

Canvas apps fail in ways that stay invisible until real users meet real data volumes: delegation warnings that silently truncate results, connector throttling, slow screen loads, and formulas that quietly evaluate to blank. The primary diagnostic tool is Live monitor (formerly called Monitor), which is available by default for all canvas apps. It traces events as they occur — formula evaluations, network calls, screen load metrics, user actions such as Navigate, Select, and SetProperty, custom Trace() output, and whether each data query was delegated to the source.

Starting a monitoring session

The exam distinguishes the two entry points:

• Studio session — open the app for editing in Power Apps Studio, then on the left pane select Advanced tools > Open live monitor. Live monitor opens in a new browser tab connected to your authoring session, and a banner labels it a Studio session. Events stream in as you preview the app.
• Published app session — on make.powerapps.com select Apps, choose the app, open the menu next to Details, select Live monitor, and then Play published app. For Power Apps mobile, select Copy monitor link instead and open that link on the device inside the mobile player.

Live monitor does not modify the app — Microsoft states it has no impact on it, so it is safe to use in a test environment or in production.

The Debug published app trap

A published app does not carry its source expressions by default, so Live monitor shows the events but cannot map them back to specific formulas. To see the expressions, turn on Settings > Debug published app and republish. The setting degrades performance for all users of the app, so disable it as soon as debugging is finished. Expect an exam option that leaves it switched on permanently — that answer is wrong.

Diagnosing delegation and performance

Live monitor event categories include Delegation, Function, Network, Parsing, Performance, Scenario, ScreenLoad, Telemetry, UserAction, and Verbose. Network events highlight error status codes, and the tool explicitly flags delegated versus non-delegated queries and cross-screen dependency warnings — two of the highest-value signals for performance work.

A classic scenario, drawn from Microsoft's own documentation example: an app that creates Dataverse rows feels slow and intermittently fails with no clear pattern. Live monitor shows each createRow call followed by a dozen getRows requests, with intermittent HTTP 429 responses — 'Rate limit exceeded. Try again in XX seconds.' The culprit is a label whose Text property calls CountRows over several tables. CountRows is not delegated for Dataverse, so every row creation re-evaluates the formula and fires extra queries, tripping platform throttling. The fix pattern: push aggregation to the data source (views, rollup columns, or delegable functions such as Filter, Search, and LookUp with delegable predicates) and cache counts in variables instead of recalculating on every event.

Remember the numbers behind delegation behavior: the non-delegable data row limit defaults to 500 and can be raised to a maximum of 2,000 (Settings > General). A non-delegated query silently processes only the first 500 rows, so the app works in development against small sample data and misbehaves in production. Live monitor is how you prove it.

Filter, download, and share the trace

• Download events as .json or .csv for offline analysis. A .json trace can be uploaded back into Live monitor later (uploading replaces the events currently shown), and trace files can be attached to Microsoft support requests.
• Invite shares your live session with any user in your organization: select Invite, pick the Microsoft Entra user, and send the generated link. Links are unique per user, cannot be shared between users, and expire after 60 minutes. Invitees see the same events including any data — a governance point worth remembering.
• Connect user works the other way around: you generate a link, an end user opens the published app through it, and you watch their event stream. Connect user requires the app to be published with Power Apps version 3.20042 or later; republish older apps to enable it.

Unsupported scenarios: Live monitor cannot attach to a canvas app embedded in a model-driven app or custom page, a SharePoint custom form app, or a Teams-embedded app — for the last one, play the app in the web player for diagnostics instead.

Test Studio at awareness level

Test Studio is the low-code tool for writing, organizing, and automating canvas-app tests. Know the vocabulary:

You must be the app's creator or co-owner to test it with Test Studio. Key limitations: no support for components, Power Apps Component Framework (PCF) code components, nested galleries, media controls, or person-type columns, and it is incompatible with the experimental Git version-control feature. Best practice: many small cases instead of one monolithic case, a single action per step, and automate repetitive, high-impact, stable tests — keep manual testing for everything else.

Preview vs play vs published

Preview (F5 inside Studio) runs the unsaved authoring copy; the web player runs the last published version that end users actually see. Diagnosing a user report against preview can waste hours — always confirm which version is live first. On make.powerapps.com, Apps > Details > Versions lists version history; Restore creates a new version from an older one (it does not delete newer versions), and you must still select Publish this version to make it live. For apps older than 6 months, restore repackages the app with the oldest available version, so functionality may differ from the original packaging.

Manual test strategies

• Galleries: test with zero, one, and many records; verify ThisItem bindings and delegation on Filter and Search.
• Forms: test New versus Edit mode, SubmitForm versus Patch, required-field validation, and the Valid property before submit.
• Patch: verify error paths with IfError and confirm the record actually committed in the data source.

Model-driven awareness

Live monitor also debugs model-driven apps, surfacing form events (load and save), network calls, page navigation, and command executions. For the exam, know the capability exists and which events it captures rather than canvas-level detail.