Study guide
6.1 Canvas App Architecture, Screens, Containers & Controls
Microsoft Power Platform Functional Consultant PL-200
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Dataverse Tables, Relationships & Core Columns
1.1 Dataverse Table Types, Properties & Ownership 1.2 Table Relationships & Cascading Rules 1.3 Column Types, Formats, Primary Keys & Alternate Keys 1.4 Rollup, Calculated & Formula Columns with Power Fx
2 Chapter 2: Dataverse Data Management & Governance
2.1 Dataverse Search, Quick Find & Relevance Indexing 2.2 Auditing Configuration & Log Management 2.3 Duplicate Detection Rules & Settings 2.4 Bulk Record Operations, Data Import, Export & Templates
3 Chapter 3: Dataverse Security Model & Access Control
3.1 Business Units, Ownership Models & Modern BU Matrix 3.2 Security Roles, Privileges & Depth Levels 3.3 Teams Architecture: Owner, Access, and Microsoft Entra (AAD) Group Teams 3.4 Column-Level Security & Hierarchy Security Models
4 Chapter 4: Model-Driven App Fundamentals & Information Architecture
4.1 Model-Driven App Design, Site Map Navigation & Modern App Designer 4.2 Form Types: Main, Quick Create, Quick View & Card Forms 4.3 View Configuration, System Views, Personal Views & Filters
5 Chapter 5: Advanced Model-Driven App Components & Custom Pages
5.1 Custom Pages & Modern Commanding with Power Fx 5.2 Form Component Controls & Specialized UX Elements 5.3 Embedding Canvas Apps in Model-Driven Forms 5.4 Embedding Power BI Reports, Dashboards & Tiles
6 Chapter 6: Canvas Apps Structure, Formulas & Data Operations
6.1 Canvas App Architecture, Screens, Containers & Controls 6.2 Power Fx Formulas, Delegation & Data Source Limits 6.3 Variables (Context, Global), Collections & State Management 6.4 Triggering Power Automate Cloud Flows from Canvas Apps
7 Chapter 7: Power Pages Site Design, Navigation & Content
7.1 Power Pages Design Studio & Site Structure 7.2 Power Pages Templates, Styling & Responsive Layouts 7.3 Web Pages, Navigation Menus & Content Snippets
8 Chapter 8: Power Pages Data Integration, Forms & Web Roles
8.1 Power Pages Lists, Basic Forms & Advanced Forms 8.2 Table Permissions, Web Roles & Page Access Security 8.3 External Identity Providers & Authentication Configuration
9 Chapter 9: Power Automate Cloud Flow Fundamentals & Triggers
9.1 Cloud Flow Types: Automated, Instant, Scheduled & Desktop Overview 9.2 Dataverse Connector Triggers & Operational Filters 9.3 Standard Connectors, Custom Connectors & Connection References
10 Chapter 10: Cloud Flow Actions, Expressions & Logic Controls
10.1 Logic Controls: Conditions, Switches, Apply to Each & Do Until Loops 10.2 Variables, Data Operations & Dynamic Content Manipulation 10.3 Power Automate Expression Language (WDL / Functions) 10.4 Error Handling, Configure Run After & Scope Controls
11 Chapter 11: Business Process Flows & Guided Processes
11.1 Business Process Flow Architecture, Stages, Steps & Data Steps 11.2 Branching Rules & Multi-Entity Business Process Flows 11.3 BPF Action Steps, Workflows & Cloud Flow Execution 11.4 BPF Security Roles, Order & Process Lifecycle
12 Chapter 12: Classic Workflows, Business Rules & Modern Logic Extensibility
12.1 Classic Dataverse Workflows: Real-Time vs. Background (Async) 12.2 Business Rules: Scope & Actions 12.3 Low-Code Plug-ins in Dataverse: Automated vs. Instant 12.4 Troubleshooting Automations, Run History & Analytics
13 Chapter 13: Power Platform Environment Architecture & Security
13.1 Environment Types: Default, Sandbox, Production, Trial, Developer 13.2 Environment Governance, Groups, Routing & Capacity Management 13.3 Data Loss Prevention (DLP) Policies & Connector Classifications
14 Chapter 14: Application Lifecycle Management (ALM) & Solutions
14.1 Unmanaged vs. Managed Solutions & Solution Layering Mechanics 14.2 Solution Components, Dependencies, Publishers & Prefixes 14.3 Exporting, Importing, Upgrading & Patches 14.4 Solution Checker, App Checker & ALM Best Practices
15 Chapter 15: Enterprise Interoperability & Service Integration
15.1 Exchange / Server-Side Synchronization & Email Integration 15.2 SharePoint & OneDrive Document Management Integration 15.3 Microsoft Word & Excel Document Templates
16 Chapter 16: Copilot, AI Capabilities & Exam Strategy
16.1 Copilot Studio & Generative AI across Power Platform 16.2 AI Builder Prebuilt & Custom Models in Apps and Flows 16.3 PL-200 Exam Strategy, Time Management & Question Analysis
6.1 Canvas App Architecture, Screens, Containers & Controls
Key Takeaways Explain This Topic AI
The App object governs application lifecycle; the StartScreen property evaluates declaratively before OnStart executes, replacing deprecated imperative Navigate() calls during app initialization.
Responsive canvas apps eliminate fixed-coordinate positioning by disabling 'Scale to fit' and utilizing Horizontal and Vertical Layout Containers with Flexible Width/Height (FillPortions) and Wrap properties.
Galleries provide virtualized, templated rendering of tabular data; avoiding heavy N+1 lookups inside gallery templates is essential for client-side rendering performance.
Edit Form controls manage record lifecycle via distinct FormModes (New, Edit, View) and declarative operations (SubmitForm, ResetForm, NewForm, EditForm, ViewForm), exposing execution state through OnSuccess, OnFailure, and LastSubmit.
Data Cards encapsulate field-level data binding through DataCardKey, DataCardValue, Default, and Update properties; unlocking cards permits deep customization such as custom controls and cascading inputs.
Last updated: August 2026
Canvas App Architecture, Screens, Containers & Controls
Microsoft Power Apps canvas apps provide functional consultants and app makers with complete, pixel-level control over user experience, layout, and data interaction. Unlike model-driven apps—which generate UI automatically from Dataverse relational metadata—canvas apps start from a blank canvas where every screen, container, control, and behavioral formula is explicitly configured. For the PL-200: Microsoft Power Platform Functional Consultant exam, you must master the fundamental building blocks of canvas apps: the application lifecycle, screen transitions, responsive container frameworks, high-performance gallery controls, and form management mechanics.
1. Canvas App Lifecycle & the App Object
Every canvas application is anchored by a top-level App object. The App object manages global application lifecycle events, initial routing, screen transitions, and unhandled exception management. +-----------------------------------------------------------------------------+
- | CANVAS APP INITIALIZATION FLOW |
- | |
- | [USER LAUNCHES APP / CLICKS DEEP LINK] |
- | | |
- | v |
- | +---------------------------------------+ |
- | | App.StartScreen | <-- Evaluated DECLARATIVELY |
- | | Determines target landing screen | BEFORE OnStart executes |
- | | (Inspects Param(), User(), Roles) | (No screen flicker!) |
- | +---------------------------------------+ |
- | | |
- | v |
- | +---------------------------------------+ |
- | | App.OnStart | <-- Imperative initialization |
- | | Caches global variables & collections | (Set, ClearCollect) |
- | | (Navigate() is DEPRECATED here!) | |
- | +---------------------------------------+ |
- | | |
- | v |
- | +---------------------------------------+ |
- | | Target Screen.OnVisible | <-- Screen-level state setup |
- | | Evaluates local context variables | (UpdateContext) |
- | +---------------------------------------+ |
- | | |
- | v |
- | [TARGET SCREEN RENDERS USER INTERFACE] |
- +-----------------------------------------------------------------------------+
- The StartScreen Property vs. App.OnStart
Historically, makers used the Navigate() function inside App.OnStart to route users conditionally (e.g., directing managers to an approval dashboard and frontline workers to an inspection form). However, executing Navigate() in OnStart causes visual stuttering, delays time-to-first-render, and degrades mobile startup performance.
Microsoft introduced the declarative App.StartScreen property to resolve this:
Declarative Evaluation: App.StartScreen is evaluated before the application loads and before App.OnStart runs. It must return an exact screen object (e.g., HomeScreen , AdminScreen , InspectionFormScreen ).
Allowed Logic: StartScreen can evaluate parameters passed via URL query strings using the Param() function, inspect the current user via User() , or evaluate offline states via Connection.Connected .
Disallowed Logic: StartScreen cannot execute state-mutating behavior functions such as Set() , UpdateContext() , Collect() , or Navigate() . // Example: App.StartScreen formula
- If(
- !IsBlank(Param("recordId")),
- RecordDetailScreen,
- User().Email in ["admin@contoso.com", "supervisor@contoso.com"],
- AdminDashboardScreen,
- StandardUserHomeScreen
- ) // Example: App.OnStart formula (Data caching & global setup only)
- Set(gblCurrentUser, User());
- Set(gblAppTheme, { Primary: ColorValue("#0078D4"), Background: ColorValue("#F3F2F1") });
- ClearCollect(colUserPermissions, UserPermissionsService.GetUserRoles(User().Email));
Important
Exam Rule for PL-200: Never use Navigate() in App.OnStart . Using Navigate() in OnStart generates a studio rule warning and will be blocked in modern runtime environments. Always use App.StartScreen for initial screen routing.
Screen Lifecycle Events & Transitions
Canvas apps consist of one or more Screens . Each screen exposes distinct lifecycle event hooks:
OnVisible : Triggers every time the user navigates into the screen. Used to reset screen-level variables, refresh specific data sources, or clear temporary selection buffers.
OnHidden : Triggers when the user navigates away from the screen. Useful for cleanup routines and resetting form states.
LoadingScreen & LoadingScreenColor : Configures the visual overlay shown while heavy data queries load on the screen.
Navigating between screens is accomplished imperatively via the Navigate() function: Navigate(DetailScreen, ScreenTransition.Fade, { locRecordId: Gallery1.Selected.ID, locMode: "Edit" })
Available ScreenTransition enum values include: ScreenTransition.Fade , ScreenTransition.Cover , ScreenTransition.CoverRight , ScreenTransition.UnCover , ScreenTransition.UnCoverRight , and ScreenTransition.None .
2. Responsive Layout Architecture & Container Controls
Traditional canvas apps relied on absolute coordinate positioning ( X , Y , Width , Height fixed integers). In modern enterprise multi-device deployments (smartphones, tablets, desktop browsers, Microsoft Teams tabs, and embedded model-driven forms), apps must be fully responsive without viewport scaling distortions. +-----------------------------------------------------------------------------+
- | RESPONSIVE CONTAINER HIERARCHY |
- | |
- | [SCREEN] (Width = App.Width, Height = App.Height) |
- | | |
- | +---> [VERTICAL CONTAINER: LayoutVertical] (Header, Body, Footer) |
- | | |
- | +--- [HEADER CONTAINER] (Flexible Height: OFF, Height: 60) |
- | | |
- | +--- [BODY CONTAINER: LayoutHorizontal] (Flex Height: ON = 1) |
- | | | |
- | | +--- [LEFT NAV / FILTER] (Flex Width: OFF, Width: 280)|
- | | | |
- | | +--- [DATA GALLERY] (Flex Width: ON, Portion: 1) |
- | | |
- | +--- [FOOTER CONTAINER] (Flexible Height: OFF, Height: 50) |
- +-----------------------------------------------------------------------------+
- Prerequisites for Responsive Canvas Apps
To enable responsive reflow, you must disable the legacy fixed-canvas scaling settings in the Power Apps Studio ( Settings > Display ):
Scale to fit: Set to Off (prevents automatic stretching/shrinking of controls with black letterboxing).
Lock aspect ratio: Set to Off (allows the app to fill arbitrary viewport aspect ratios).
Lock orientation: Set to Off (allows fluid rotation between portrait and landscape modes).
Layout Containers: Horizontal vs. Vertical
Power Apps provides specialized layout containers that automatically position and resize child controls:
Horizontal Container ( LayoutHorizontal ): Arranges child elements in a horizontal sequence (left-to-right). When wrapping is enabled, overflowing children wrap to the next row.
Vertical Container ( LayoutVertical ): Stacks child elements in a vertical sequence (top-to-bottom). When wrapping is enabled, overflowing children wrap to the next column.
Standard Container ( Container ): A logical grouping container that does not enforce automatic flex positioning, but allows grouped visibility, coordinate relative positioning, and component encapsulation.
Key Container Layout Properties
Property Values Operational Purpose
LayoutDirection LayoutDirection.Horizontal , LayoutDirection.Vertical Establishes whether child controls flow horizontally across or vertically down.
LayoutJustifyContent Start , Center , End , SpaceBetween , SpaceAround , SpaceEvenly Controls alignment along the primary axis (e.g., distributing cards evenly across the header bar).
LayoutAlignItems Start , Center , End , Stretch Controls alignment along the cross axis (e.g., vertically centering buttons within a horizontal bar).
LayoutWrap true / false When enabled, child items wrap to a new line/column when the container boundary is exceeded.
LayoutGap Number (e.g., 8 , 16 ) Sets pixel spacing between adjacent child controls inside the container.
Child Control Sizing Inside Layout Containers
When a control is placed inside a layout container, new responsive properties appear:
Flexible width ( FillPortions ) / Flexible height: When toggled on, the child control automatically expands to fill available remaining space in the container. If multiple controls have flexible sizing enabled, space is allocated according to their FillPortions ratio (e.g., 2 portions vs. 1 portion).
Minimum width ( MinWidth ) / Minimum height ( MinHeight ): Prevents controls from shrinking below a functional touch or readability threshold.
Align in container: Overrides the container's default LayoutAlignItems for that specific child control ( Start , Center , End , Stretch , or Set by container ).
Screen Size Breakpoints ( Screen.Size )
Canvas apps evaluate viewport dimensions dynamically using the built-in Screen.Size property, returning an integer (1 to 4) corresponding to standard responsive breakpoints: // Adaptive column count formula for a Gallery or responsive grid
- Switch(
- Self.Size,
- ScreenSize.Small, 1, // Phone / Narrow Viewport (< 600px)
- ScreenSize.Medium, 2, // Tablet Portrait (600px - 900px)
- ScreenSize.Large, 3, // Tablet Landscape / Small Desktop (900px - 1200px)
- ScreenSize.ExtraLarge, 4 // Widescreen Desktop (> 1200px)
- )
- 3. Core User Interface Controls & Data Binding
Canvas applications interact with users through specialized input, display, and data-bound controls.
The Gallery Control ( Gallery )
The Gallery control is the primary component used to display repeating, tabular lists of records.
Templated Architecture: You design the first item cell (the Template ), and the gallery automatically replicates that template structure across all items in its Items property.
Key Properties:
Items : The tabular dataset or collection providing records (e.g., Filter(Accounts, StateCode = 'State (Accounts)'.Active) ).
TemplateSize : Height (in vertical galleries) or Width (in horizontal galleries) of each individual item cell.
TemplatePadding : Internal margin separating each item cell.
Selected : References the active record selected by the user (e.g., Gallery1.Selected.Telephone1 ).
AllItems : Returns a table representing all loaded items currently rendered inside the gallery.
ThisItem Scope: Inside any control placed within the gallery template, ThisItem refers specifically to the record bound to that template instance (e.g., ThisItem.AccountName ).
Tip
Performance Tip (PL-200 Exam): Avoid placing LookUp() formulas inside labels within a gallery template. If a gallery renders 100 rows, a LookUp() in each row triggers 100 separate synchronous network queries (the classic N+1 problem). Instead, use Dataverse relationship dot-notation (e.g., ThisItem.PrimaryContact.FullName ) or pre-join data into a collection before binding to the gallery.
The Edit Form & Display Form Controls
Forms provide standardized, schema-driven data entry and record presentation for connected data sources. +-----------------------------------------------------------------------------+
- | EDIT FORM LIFECYCLE & METHODS |
- | |
- | 1. INITIALIZE FORM: |
- | - NewForm(Form1) ---> Sets FormMode.New (Blank fields, Default values) |
- | - EditForm(Form1) ---> Sets FormMode.Edit (Loads Form1.Item for edits) |
- | - ViewForm(Form1) ---> Sets FormMode.View (Read-only presentation) |
- | | |
- | v |
- | 2. USER ENTERS DATA & CLICKS SUBMIT: |
- | SubmitForm(Form1) |
- | | |
- | +---> Data Validated & Sent to Backend |
- | | |
- | +---> [SUCCESS] ---> Triggers Form1.OnSuccess |
- | | (Access Form1.LastSubmit) |
- | | |
- | +---> [FAILURE] ---> Triggers Form1.OnFailure |
- | (Access Form1.Error / ErrorMessage)|
- +-----------------------------------------------------------------------------+
- Form Lifecycle Functions & Properties
Function / Property Type Description & Purpose
DataSource Property The underlying table/entity (e.g., Accounts , WorkOrders ).
Item Property The specific record being viewed or edited (e.g., Gallery1.Selected or LookUp(Accounts, AccountId = locCurrentId) ). Ignored in New mode.
Mode Property Evaluates to FormMode.New , FormMode.Edit , or FormMode.View .
NewForm(Form) Function Puts form in FormMode.New and prepares blank fields for creating a new record.
EditForm(Form) Function Puts form in FormMode.Edit to modify the record defined in Form.Item .
ViewForm(Form) Function Puts form in FormMode.View , rendering all fields as read-only.
ResetForm(Form) Function Discards uncommitted user edits and reverts all card values to initial defaults.
SubmitForm(Form) Function Validates all cards and commits changes to the underlying data source.
OnSuccess Behavior Property Runs immediately after successful backend write. Ideal for Notify("Saved!") or navigating away.
OnFailure Behavior Property Runs if backend rejection or network error occurs. Exposes Form.Error and Form.ErrorMessage .
LastSubmit Property Returns the complete record payload that was just committed, including auto-generated primary key GUIDs and server timestamps.
Unsaved Property Boolean indicating if the user has modified values in any card that have not yet been submitted.
Data Cards Architecture
When fields are added to an Edit Form, Power Apps wraps each field inside a Data Card control:
DataCardKey : Text label showing the display name of the field.
DataCardValue : The interactive input control (Text input, Dropdown, Toggle, DatePicker).
Update Property: The most critical property on the card. Specifies the exact Power Fx formula that writes data back to the data source when SubmitForm() executes (e.g., DataCardValue12.Text or Dropdown1.Selected.Value ).
Default Property: Determines what value is initially populated in the input control when the form loads (e.g., ThisItem.Telephone1 ).
Unlocking Data Cards: By default, cards are locked to preserve schema integrity. To replace standard controls (e.g., replacing a plain text box with a Star Rating control, a Barcode Reader, or a rich HTML text editor), you must select the card, go to the Advanced properties tab, and click Unlock to change properties .
Input Controls: Text Input, Dropdown, ComboBox & DatePicker +-----------------------------------------------------------------------------+
- | DROPDOWN VS COMBOBOX COMPARISON |
- | |
- | [DROPDOWN CONTROL] [COMBOBOX CONTROL] |
- | - Single-item selection only - Single OR Multi-select support |
- | - No type-ahead search filtering - Searchable (IsSearchable=true) |
- | - Simple string array or single column - Multi-column search fields |
- | - Output: Dropdown.Selected.Value - Output: ComboBox.SelectedItems |
- +-----------------------------------------------------------------------------+
TextInput : Supports single-line, multi-line, and password formats; triggers OnChange when focus leaves the control.
Dropdown : Lightweight selector for small, static string lists. Supports only single selection and does not provide text search filtering.
ComboBox : Enterprise-grade selector. Supports multi-select ( SelectMultiple = true ), type-ahead search ( IsSearchable = true ), searching across multiple column attributes ( SearchFields = ["fullname", "emailaddress1"] ), and setting complex initial selections via DefaultSelectedItems .
DatePicker : Calendar date picker. Exposes SelectedDate and format options for localized calendar formats.