PL-900 Objective 3.2: Build a Canvas App

 • 31 min read • Microsoft Power Platform Fundamentals

Share:

PL-900 Exam Focus: This objective covers practical canvas app development including connecting to data through connectors, using common controls like galleries and forms, building responsive layouts with containers, implementing AI capabilities through Copilot controls, and sharing finished applications with users. Understanding these building blocks enables you to create functional business applications without traditional programming, demonstrating Power Apps' low-code development value proposition.

Canvas App Development Fundamentals

Building canvas apps involves composing visual controls on screens, connecting those controls to data sources, writing formulas that define behavior, and configuring properties that determine appearance and functionality. The development process resembles creating presentations in PowerPoint or designing graphics in visual tools rather than writing code in text editors. Makers see immediate visual feedback as they add controls, write formulas, and configure properties, enabling rapid iteration and refinement. This visual, low-code approach democratizes application development, allowing business users who understand requirements deeply to create solutions without extensive programming training.

The canvas app architecture separates presentation from data, with screens displaying information and accepting input while data sources provide and store information. Controls on screens bind to data through formulas, displaying current values and writing changes back when users interact. This declarative binding approach means makers describe what data should appear rather than writing procedural code managing data flow. The platform handles complexity including data refresh, change tracking, and conflict resolution automatically, letting makers focus on user experience and business logic rather than technical plumbing.

Connecting to Data Sources Using Connectors

Understanding Connectors

Connectors provide standardized interfaces between Power Apps and external data sources or services, abstracting technical integration details behind visual configuration experiences. Each connector handles authentication, API communication, data format translation, and error handling automatically, eliminating the need for makers to understand REST APIs, OAuth protocols, or JSON parsing. Organizations leverage existing data investments without requiring data migration or consolidation, building applications that span SharePoint lists, SQL databases, cloud services, and custom APIs through consistent connector interfaces.

Power Platform includes over 500 pre-built connectors covering common business systems, productivity tools, social media platforms, and specialized services. Microsoft-maintained connectors receive ongoing updates supporting new capabilities as underlying services evolve, ensuring applications continue working without modification. When pre-built connectors don't exist for specific services, custom connectors enable integration with proprietary systems or unique APIs using OpenAPI specifications that define endpoints, authentication requirements, and data schemas. This connector ecosystem makes Power Apps a universal front-end for diverse backend systems.

Adding Data Connections

Adding data connections begins in the Data panel where makers browse available connectors, search for specific services, or select from recently used connections. After selecting a connector, makers provide required credentials like usernames and passwords, API keys, or OAuth authorization depending on the service. The platform stores these credentials securely, reusing them for subsequent connections without requiring repeated authentication. Once connected, the data source appears in the data panel with its tables, lists, or collections available for use throughout the application.

Connection configuration varies by service. SharePoint connections require selecting specific sites and lists, SQL Server connections need server addresses and database names, Excel connections point to specific files in OneDrive or SharePoint, and REST API connections define endpoints and parameters. The visual connection wizard guides makers through required configuration, validating settings before completing connections. Applications can include multiple connections to different services, even connecting to multiple instances of the same service like different SharePoint sites or SQL databases.

Working with Connected Data

Common Data Operations:

  • Displaying data: Gallery and data table controls display collections of records from connected sources. Makers set the Items property to data sources like SharePoint lists or SQL tables, with controls automatically showing all records or filtered subsets based on formulas.
  • Filtering and searching: Filter() functions create data subsets matching specific criteria, while Search() functions find records containing text in specified fields. These operations execute server-side when possible, ensuring performance with large datasets without downloading all records locally.
  • Creating records: Patch() or SubmitForm() functions write new records to connected data sources. Makers collect user input through text inputs, dropdowns, and other controls, then execute functions that package values and submit them through connectors to underlying systems.
  • Updating records: Patch() functions modify existing records by specifying which record to update and which fields to change. Edit forms bind to data sources, automatically loading current values and saving changes when users submit forms.
  • Deleting records: Remove() functions delete records from connected sources based on specified criteria or selected gallery items. Applications typically include confirmation prompts before executing deletions to prevent accidental data loss.

Common Canvas App Controls

Input Controls

Input controls collect information from users, enabling data entry and selection through familiar interface patterns. Text input controls accept typed text with configurable hints, default values, and character limits. Dropdown controls present predefined choices, ensuring data consistency by restricting input to approved values. Date picker controls provide calendar interfaces for date selection without manual typing. Combo box controls combine dropdown functionality with search capabilities, supporting large option lists where scrolling would be impractical. Slider controls enable numeric value selection through visual manipulation, useful for ratings or ranges.

Toggle and checkbox controls capture yes/no or true/false values through simple interaction models. Radio button groups present mutually exclusive options where exactly one choice is always selected. Pen input controls capture handwritten signatures or drawings, essential for approvals and sketches. Camera controls access device cameras for photo capture directly within applications. Each input control exposes properties like Default (initial value), Value (current value), and OnChange (formula executing when value changes), enabling rich interactive behaviors through formula logic.

Display Controls

Display controls present information to users without accepting input, formatting data for readability and comprehension. Label controls display static or dynamic text with configurable fonts, sizes, colors, and alignment. Image controls show pictures from URLs, data sources, or uploaded files with sizing and cropping options. Icon controls provide visual indicators using predefined symbol libraries or custom SVG graphics. Video and audio controls play media files, supporting both streaming sources and uploaded content.

HTML text controls render formatted content including bold, italic, lists, and links, useful for rich text descriptions or help content. Timer controls display countdowns or track elapsed time, triggering actions when durations complete. Progress indicators show completion status for long-running processes through bars or spinners. Chart controls visualize data through column, bar, line, or pie charts generated from data source values. These display controls transform raw data into understandable visual representations that communicate meaning effectively to users.

Gallery Controls

Gallery controls represent one of the most powerful and commonly used controls in canvas apps, displaying collections of records in scrollable lists with customizable item templates. Vertical galleries scroll top-to-bottom, ideal for mobile interfaces and lengthy lists. Horizontal galleries scroll left-to-right, working well for card-based presentations or featured items. Flexible height galleries adjust item height based on content, accommodating varying amounts of information without wasted space.

Gallery templates define how each record appears, with makers adding labels, images, buttons, and other controls that repeat for every data item. Template controls reference ThisItem to access current record data, displaying different values automatically as the gallery scrolls. Users select gallery items by tapping or clicking, with selected items accessible through gallery's Selected property. This selection capability enables master-detail patterns where selecting list items updates forms or displays detailed information on adjacent screens. Galleries support filtering, sorting, and searching large datasets efficiently, making them essential for any application displaying multiple records.

Form Controls

Form controls provide structured interfaces for viewing and editing complete records, automatically generating appropriate input controls for each data source field. Edit forms bind to data sources and selected records, loading current values into input fields and saving changes when users submit. Display forms show read-only record information in formatted layouts. New forms present blank fields for creating new records.

Form configuration includes specifying which fields appear, their order, and whether they're required or optional. Data cards within forms contain individual fields with labels, input controls, and validation messages. Forms handle validation automatically based on data source requirements, preventing submission until all required fields contain valid values. The FormMode property (New, Edit, or View) determines form behavior, with makers switching modes through formulas triggered by button clicks or gallery selections. This built-in record management functionality dramatically reduces development effort compared to manually building create, read, update interfaces.

Building Responsive Pages with Containers

Container Control Fundamentals

Container controls revolutionize responsive design in canvas apps by managing layout automatically as screen sizes change. Rather than positioning every control with absolute X and Y coordinates that look correct only on specific screen sizes, containers arrange child controls using flexible layout rules that adapt intelligently. Horizontal containers arrange controls left-to-right with automatic wrapping when space runs out. Vertical containers stack controls top-to-bottom. Containers can nest within other containers, creating sophisticated responsive layouts that work across desktop monitors, tablets, and mobile phones without separate designs for each form factor.

Container properties control layout behavior including padding (space inside containers), gaps (space between child controls), alignment (how controls position within available space), and wrapping (whether controls flow to new rows or columns). Fill containers expand to occupy available space, while fit containers size themselves based on content. These flexible sizing options enable layouts that prioritize important content, adapt to varying information amounts, and maintain visual hierarchy across different display sizes. The container-based approach makes apps more maintainable since layout adjusts automatically rather than requiring manual repositioning when content changes.

Responsive Design Patterns

Common Responsive Layouts:

  • Master-detail layout: Horizontal container holds vertical containers for list and detail views side-by-side on wide screens, automatically stacking on narrow screens. Users see lists and details simultaneously on desktops while mobile users navigate between them.
  • Card-based layouts: Horizontal containers with wrapping display cards that flow across multiple rows as needed. Desktop shows several cards per row while mobile displays one card per row, all from the same container configuration.
  • Form layouts: Vertical containers organize form fields, with nested horizontal containers grouping related fields on wide screens. Mobile automatically stacks all fields vertically for easy scrolling and input.
  • Navigation patterns: Top-level containers switch between visible and collapsed states based on screen width. Desktop shows side navigation while mobile collapses it behind hamburger menus, maintaining functionality across devices.
  • Dashboard layouts: Nested containers arrange charts, KPIs, and metrics in responsive grids. Desktop presents comprehensive dashboards while mobile prioritizes critical information, hiding or collapsing secondary content.

Screen Orientation and Breakpoints

Canvas apps detect screen dimensions and orientation through built-in properties like App.Width, App.Height, and App.ActiveScreen.Orientation. Formulas reference these values to conditionally show or hide controls, adjust sizes, or switch between layouts based on available space. Makers define breakpoints (screen width thresholds) where layouts change significantly, typically distinguishing between mobile (under 600 pixels), tablet (600-1200 pixels), and desktop (over 1200 pixels) views. Container visibility, control sizes, and property values adjust through formulas evaluating current screen width against these breakpoints.

Orientation changes between portrait and landscape modes require similar adaptation. Applications designed for mobile might rearrange navigation from bottom bars in portrait to side panels in landscape, maximizing content area while maintaining usability. Testing across different screen sizes and orientations identifies layout problems before deployment, with the responsive preview feature showing how applications appear on various devices. This preview capability enables iterative refinement, ensuring applications work well across the diverse devices organizations use without requiring physical testing on every device type.

Copilot Controls Capabilities

AI-Powered User Interaction

Copilot controls bring generative AI capabilities directly into canvas apps, enabling natural language interaction with application data and AI-powered content generation. These controls reduce training requirements by allowing users to express needs conversationally rather than learning specific application navigation or query syntax. The AI understands intent, context, and data structure, translating natural language into appropriate queries, filters, or actions. This conversational interface particularly benefits occasional users, executives, or situations where traditional interfaces would require extensive training.

Text Copilot controls let users ask questions about data displayed in applications. A sales dashboard might include Copilot enabling questions like "which accounts generated the most revenue last quarter" or "show me open opportunities over $50,000." The AI interprets these queries, filters underlying data appropriately, and presents results conversationally or through updated visualizations. Users refine queries through follow-up questions, drilling into information naturally without navigating menus or configuring filters manually. This query capability makes applications more accessible and reduces the technical knowledge required to extract insights from data.

Content Generation

Image Copilot controls generate visual content from text descriptions, useful for creating placeholder images, generating conceptual illustrations, or providing visual variety in applications. Users describe desired images in natural language ("a professional business meeting in a modern office" or "a chart showing upward growth trend"), and the AI generates appropriate images matching descriptions. While generated images may not always perfectly match requirements, they provide quick visual content without requiring stock photo subscriptions or graphic design skills.

Text generation capabilities help users draft content within applications. Email composition features suggest complete messages based on brief prompts. Report generation features create summaries from data and bullet points. Product description generators expand key features into marketing copy. These AI-assisted creation capabilities accelerate content production while maintaining human oversight and editing. Users guide AI through prompts and regeneration, selecting from alternatives until output meets requirements. The iterative refinement process balances AI efficiency with human judgment and expertise.

Implementation Considerations

⚠️ Copilot Control Best Practices:

  • Data scope management: Limit Copilot controls to appropriate data subsets rather than entire databases. Configure which tables and fields AI can access, preventing queries against sensitive information or irrelevant data that could confuse users.
  • User guidance: Provide example queries or suggestions showing what users can ask. Natural language is powerful but users may need initial guidance about capabilities and how to phrase effective questions.
  • Result validation: Design applications assuming AI results may need verification. Include options for users to review underlying data, understand how AI arrived at answers, and manually verify critical information.
  • Performance expectations: AI-powered features require cloud services and may have latency compared to traditional controls. Set user expectations appropriately and provide loading indicators for operations requiring significant processing time.
  • Licensing awareness: Copilot features may require premium licensing beyond standard Power Apps capabilities. Verify licensing requirements before deploying apps with Copilot controls to production users.

Sharing Canvas Apps

App Sharing Process

Sharing canvas apps makes them available to other users through the Power Apps maker portal sharing interface. Makers select applications and click share buttons, opening dialogs where they specify users or security groups receiving access. Email addresses or Azure AD group names define recipients, with autocomplete suggesting matches as makers type. Apps can be shared with individual users for targeted access or security groups for scalable management where group membership automatically determines app access without individual sharing for every user.

Two permission levels control what shared users can do. User permission provides app access for running and using applications without editing capabilities. This permission is appropriate for end users who need applications for their work but shouldn't modify designs or logic. Co-owner permission grants full access including editing app design, managing connections, and sharing with additional users. Co-owners collaborate on app development, with changes immediately visible to all co-owners. Organizations typically limit co-owner permissions to developers and trusted power users while most users receive user permissions for consumption only.

Data Source Permissions

Sharing apps doesn't automatically grant access to underlying data sources, requiring separate permission management for connectors and data. When apps use SharePoint lists, shared users need list access through SharePoint permissions. SQL database connections require database credentials or appropriate SQL permissions. Apps using premium connectors need recipients to have premium Power Apps licensing even if apps share successfully. The sharing interface identifies data source permission requirements, prompting makers to grant necessary access or verify recipients have appropriate permissions.

Some connectors use app maker credentials when accessing data (implicit connections), while others require each user to provide their own credentials (explicit connections). Implicit connections share data access broadly, appropriate when all users should access the same data with maker-level permissions. Explicit connections ensure users access only data they're authorized to see based on their individual credentials, maintaining security boundaries. SQL Server, SharePoint, and Dataverse typically use explicit connections where user identity determines data access, while many cloud services use implicit connections where app credentials access data uniformly.

App Discovery and Access

Shared apps appear automatically in recipients' Power Apps mobile app and web portal (make.powerapps.com) without requiring manual installation or downloads. The mobile app shows available apps on home screens, while the web portal lists apps in the Apps section. Users launch applications with single taps or clicks, with apps loading in mobile app containers or web browsers depending on access method. This automatic discovery ensures users find shared apps easily without complex distribution or installation procedures.

Organizations can embed canvas apps in SharePoint pages, Teams channels, or Power BI dashboards, bringing applications directly into existing workflows rather than requiring navigation to Power Apps portals. These embedded scenarios maintain sharing rules, with apps displaying only for users with appropriate permissions. Embedding options make apps more discoverable by placing them where users already work, improving adoption by reducing the friction of accessing applications through separate portals or mobile apps.

Real-World Canvas App Building Scenarios

Scenario 1: Expense Submission Mobile App

Requirements: Employees need to submit expense reports from mobile devices, capturing receipt photos, expense details, and categories.

Implementation: Canvas app connects to Dataverse table storing expense records. Camera control captures receipt photos stored in Dataverse file columns. Text inputs collect amounts and descriptions. Dropdown selects expense categories. Gallery on home screen shows submitted expenses with status indicators. Form control handles data submission. Responsive containers ensure usability on phones and tablets.

Sharing: App shared with all employees through organization-wide security group, using explicit Dataverse connection so employees see only their own expenses. Managers receive co-owner permission for app maintenance.

Scenario 2: Customer Lookup Dashboard

Requirements: Sales team needs quick access to customer information from CRM system combined with recent orders from ERP system.

Implementation: Canvas app connects to both Salesforce (premium connector) and SQL Server database. Search input filters customer gallery using Filter() formula. Selected customer displays in form showing CRM details. Separate gallery shows related orders from SQL using customer ID relationship. Copilot control enables natural language queries like "show customers with orders over $10,000 this month."

Sharing: App shared with sales team security group, requiring Power Apps per user licenses for premium Salesforce connector. Users authenticate to both data sources using their own credentials.

Scenario 3: Facility Inspection Tool

Requirements: Facility managers conduct safety inspections, documenting issues with photos and descriptions, working offline when necessary.

Implementation: Canvas app configured for offline use caches inspection checklists from SharePoint. Toggle controls mark inspection items as pass/fail. Camera control captures issue photos. Text inputs collect notes. GPS control records inspection locations. Container-based layout adapts between tablet landscape for field use and mobile portrait for office review. Data syncs automatically when connectivity resumes.

Sharing: App shared with facility management team, with explicit SharePoint permissions ensuring inspectors access only assigned facilities. Offline collections configured with appropriate sync rules.

Exam Preparation Tips

Key Concepts to Master

  • Connectors: Understand they enable data source integration without coding, with standard and premium categories
  • Gallery controls: Know they display collections of records with scrollable, customizable layouts
  • Form controls: Recognize they manage record viewing, editing, and creation automatically
  • Containers: Understand they enable responsive design by managing layout across screen sizes
  • Copilot controls: Know they add AI-powered natural language capabilities to apps
  • Sharing: Understand user vs co-owner permissions and data source permission requirements

Practice Questions

Sample PL-900 Exam Questions:

  1. A canvas app needs to display a scrollable list of products from a SQL database. Which control type is most appropriate?
  2. An organization wants their app to work on desktop computers, tablets, and phones with appropriate layouts for each. Which feature enables this responsive design?
  3. Users should be able to ask natural language questions about data displayed in an app. Which feature provides this capability?
  4. What permission level allows users to run an app but not modify its design?
  5. An app connects to both SharePoint and Salesforce data sources. What term describes the interfaces enabling these connections?

PL-900 Success Tip: Focus on understanding component purposes rather than specific formula syntax. Know that connectors enable data connections, galleries display lists, forms handle record management, and containers provide responsive layouts. Understand Copilot controls add AI features for natural language interaction. Remember sharing requires both app permissions and data source permissions. Practice identifying which controls and features address specific requirements in scenario-based questions.

Hands-On Practice Lab

Lab Objective

Build a functional canvas app demonstrating connectors, controls, containers, and sharing. This lab requires Power Apps maker portal access with data source availability.

Lab Activities

Activity 1: Connect to Data and Build Gallery

  • Create blank app: Start new canvas app from blank template for phone or tablet form factor
  • Add data connection: Connect to SharePoint list, Excel file in OneDrive, or Dataverse table with sample data
  • Insert gallery: Add vertical gallery control and set its Items property to connected data source
  • Customize template: Modify gallery template to display relevant fields from your data source

Activity 2: Add Form for Data Entry

  • Add new screen: Insert second screen for displaying record details
  • Insert edit form: Add form control connected to same data source as gallery
  • Configure fields: Select which fields appear in form and set their order
  • Add navigation: Create button on gallery screen that navigates to form screen and loads selected record

Activity 3: Implement Responsive Layout

  • Add container: Insert vertical container on your gallery screen and move gallery inside it
  • Add search: Place text input above gallery in container for search functionality
  • Configure container properties: Adjust padding, gaps, and alignment for professional appearance
  • Test responsiveness: Preview app at different screen sizes and observe layout adaptation

Activity 4: Share Application

  • Save app: Ensure application is saved with descriptive name
  • Access sharing: Navigate to app sharing interface in maker portal
  • Share with colleague: Add a colleague or test user with user permission level
  • Verify access: Have recipient confirm app appears in their Power Apps portal or mobile app

Lab Outcomes

After completing this lab, you'll have practical experience building canvas apps with data connections, galleries displaying records, forms for data entry, responsive containers, and sharing with users. This hands-on knowledge demonstrates core canvas app development capabilities tested in the PL-900 exam and provides foundation for building business applications.

Frequently Asked Questions

What are connectors in Power Apps?

Connectors are pre-built interfaces that enable Power Apps to communicate with external data sources and services including SharePoint, Office 365, SQL Server, Salesforce, Twitter, and hundreds of other systems. They abstract the technical complexity of API authentication, data formats, and communication protocols, allowing makers to connect apps to data sources through visual configuration rather than writing integration code. Connectors support both reading data for display and writing data for create, update, or delete operations. Power Platform includes standard connectors available with basic licensing and premium connectors requiring additional licenses for enterprise services.

What is a gallery control in canvas apps?

Gallery controls display collections of data in scrollable lists, presenting multiple records with customizable layouts. They support vertical scrolling for mobile-optimized lists, horizontal scrolling for card-based presentations, and flexible height configurations adapting to content. Makers define gallery templates showing how each record appears, with controls inside templates automatically repeating for every data record. Galleries support filtering, sorting, and searching large datasets efficiently, making them essential for displaying lists like customers, products, orders, or any collection of business records. Users select gallery items to view details or trigger actions.

What are container controls used for?

Container controls group related controls together and manage their layout and responsiveness automatically. They enable building responsive applications that adapt intelligently to different screen sizes without manually repositioning every control. Horizontal containers arrange child controls left-to-right with automatic wrapping, while vertical containers stack controls top-to-bottom. Containers support flexible sizing where controls grow or shrink proportionally, fixed positioning for precise layouts, and nested containers creating complex responsive designs. This container-based approach replaces traditional absolute positioning, making apps more maintainable and providing better experiences across desktop, tablet, and mobile devices.

What can Copilot controls do in canvas apps?

Copilot controls add AI-powered capabilities to canvas apps enabling users to interact through natural language. Text Copilot controls let users ask questions about app data in conversational English, with AI interpreting intent and generating appropriate responses. Users can request information like "show me high-priority tasks due this week" or "what's the total value of open opportunities," with Copilot querying connected data sources and presenting results. Image Copilot controls generate images based on text descriptions, useful for creating visual content within apps. These AI features make applications more intuitive, reducing training requirements and improving user productivity through natural interaction patterns.

How do you share canvas apps with users?

Canvas apps are shared from the Power Apps maker portal by selecting apps and choosing share options that specify which users or security groups receive access. Makers can grant co-owner permissions allowing others to edit and reshare apps, or user permissions providing app access without editing capabilities. When sharing apps connected to premium data sources or using premium features, recipients must have appropriate Power Apps licensing. Shared apps appear in users' Power Apps mobile app or web portal automatically, requiring no manual installation. Sharing includes configuring data source permissions ensuring users can access underlying data, and makers can revoke access anytime through the same sharing interface.

Can canvas apps connect to multiple data sources simultaneously?

Yes, canvas apps can connect to multiple data sources simultaneously, enabling applications that consolidate information from diverse systems into unified experiences. A single app might display SharePoint tasks, SQL Server customer data, and Salesforce opportunities on the same screen, with users interacting seamlessly without knowing data comes from different sources. Makers add multiple connections through the data panel, writing formulas that reference each source appropriately. This multi-source capability eliminates the need for complex data integration projects or forcing all data into single systems, allowing organizations to leverage existing investments while providing integrated user experiences.

What is the difference between standard and premium connectors?

Standard connectors connect to common productivity services like Office 365, SharePoint, OneDrive, and popular cloud services, available with basic Power Apps licensing without additional costs. Premium connectors access enterprise-grade systems and specialized services including SQL Server, Salesforce, HTTP services with authentication, on-premises data through gateways, and Dynamics 365 applications. Using premium connectors requires Power Apps per user or per app licenses beyond basic Microsoft 365 licensing. The distinction helps organizations control costs by identifying which apps require premium licensing, while standard connectors enable broad app development without licensing barriers.

How do formulas work in canvas apps?

Formulas in canvas apps use Power FX, an Excel-like formula language that controls app behavior, manipulates data, and implements logic. Makers write formulas in property fields defining how controls behave, what data they display, and when they're visible. Common formulas include Filter() for querying data subsets, Navigate() for screen transitions, Patch() for updating records, If() for conditional logic, and text operations like Concatenate() or Upper(). Formulas reference control properties like TextInput1.Text, data sources like Customers, and built-in functions similar to Excel. IntelliSense provides suggestions and documentation while typing, helping makers discover available functions and correct syntax without memorizing commands.

Share:

Written by Joe De Coppi - Last Updated November 14, 2025

Previous: Objective 3.1 Identify Power Apps Capabilities

Next: Objective 3.3 Build Model Driven App