Power Apps Development

Power Apps Development

Power Apps Overview

Microsoft Power Apps is a low-code application development platform in the Power Platform family. It provides two primary app types:

Canvas Apps give full pixel-level control over the UI. Developers drag controls onto a canvas, bind them to data sources, and write Power Fx formulas for behavior and logic. Canvas apps run in a browser or mobile player.

Model-Driven Apps are built on top of Dataverse tables. The UI is auto-generated from the data model — forms, views, dashboards, and business process flows are configured rather than designed from scratch. Model-driven apps enforce consistent navigation, security roles, and business rules.

Power Fx Language

Power Fx is the formula language used in canvas apps (and increasingly across Power Platform). It's inspired by Excel formulas, making it approachable for spreadsheet users.

Core Functions

Data operations:

• Patch(DataSource, Record, Changes) — Create or update a record. The most important data write function.
• Collect(Collection, Records) — Add records to a collection (local in-memory table) or data source.
• ClearCollect(Collection, Records) — Clear a collection and add new records.
• Remove(DataSource, Record) — Delete a record.
• UpdateIf(DataSource, Condition, Changes) — Update records matching a condition.
• RemoveIf(DataSource, Condition) — Delete records matching a condition.
• LookUp(DataSource, Condition, Column) — Return the first matching record or column value.
• Filter(DataSource, Condition) — Return all matching records.
• Search(DataSource, SearchText, Column1, Column2) — Full-text search across columns.
• Sort(Table, Column, Order) — Sort a table by a column.
• SortByColumns(Table, Column1, Order1, Column2, Order2) — Multi-column sort.

Text:

• Concatenate(str1, str2) or str1 & str2 — Join strings.
• Text(Value, Format) — Format numbers, dates, and times as text.
• Value(Text) — Parse text to a number.
• Left, Right, Mid, Len, Find, Substitute, Upper, Lower, Trim.

Logic:

• If(Condition, TrueResult, FalseResult) — Conditional branching.
• Switch(Value, Match1, Result1, Match2, Result2, DefaultResult) — Multi-way branching.
• IsBlank(Value), IsEmpty(Table) — Null and empty checks.
• Coalesce(Value1, Value2) — Return first non-blank value.

Navigation:

• Navigate(Screen, Transition, Context) — Navigate to a screen with optional context variables.
• Back() — Return to the previous screen.
• Set(Variable, Value) — Set a global variable.
• UpdateContext({Var1: Value1}) — Set context (screen-scoped) variables.

User:

• User() — Returns .Email, .FullName, .Image of the signed-in user.

Delegation

Delegation is the most critical performance concept in canvas apps. When a formula can be delegated, the data source (e.g., Dataverse, SharePoint, SQL) processes the query server-side and returns only the results. When delegation is not supported, Power Apps downloads up to 500 (or 2,000 max) rows and processes locally.

Delegable functions: Filter, Sort, SortByColumns, Search (Dataverse only), LookUp, FirstN.

Delegable operators (varies by data source): =, <>, <, >, <=, >=, &&, ||, !, in, exactin, StartsWith.

Non-delegable (always local): CountRows, Sum, Average, GroupBy, AddColumns, DropColumns, ShowColumns, RenameColumns, Distinct, First, Last, ForAll (as aggregate), Concat.

Dataverse has the broadest delegation support. SharePoint and SQL Server have partial support. Excel has no delegation.

Collections and Variables

• Global variables (Set): Accessible from any screen. Used for app-wide state (selected record, user preferences).
• Context variables (UpdateContext): Screen-scoped. Reset when navigating away. Good for modal dialogs and temporary state.
• Collections (Collect, ClearCollect): In-memory tables. Used for offline caching, temporary data manipulation, and multi-step form workflows.

Error Handling

• IfError(Value, Fallback) — Return fallback if the value is an error.
• IsError(Value) — Check if a value is an error.
• Notify(Message, NotificationType) — Display a toast notification. Types: Success, Error, Warning, Information.
• Errors(DataSource) — Return a table of errors from the last data operation.

Model-Driven App Configuration

Forms

Model-driven app forms are configured via Dataverse form designer or solution XML:

• Main forms: Full-page record forms with tabs, sections, and controls.
• Quick create forms: Compact forms for rapid data entry (modal).
• Quick view forms: Read-only embedded views of related records.
• Card forms: Compact representations for mobile views.

Key form elements: tabs, sections, columns, sub-grids (related records), business process flows, timeline (notes/activities), web resources.

Views

Views are saved queries that display records in a grid:

• Public views: Available to all users.
• Personal views: Created by individual users.
• System views: Default views (Active Records, Inactive Records, etc.).
• Quick find views: Used by the search bar.

Defined by a FetchXML query and a layoutxml for column display.

Business Rules

Declarative server-side or client-side logic on forms:

• Show/hide fields based on conditions.
• Set field values.
• Set required/optional fields.
• Show error messages.
• Lock/unlock fields.

Business rules run without code and are defined in the Dataverse solution.

Business Process Flows

Guided multi-stage processes that walk users through a defined workflow. Each stage has steps (fields to complete). Stages can span multiple tables (e.g., Lead → Opportunity → Order).

Site Map

Defines the navigation structure: areas → groups → sub-areas (links to tables, dashboards, web resources, or custom pages).

Custom Connectors

Custom connectors wrap external REST APIs for use in Power Apps, Power Automate, and Copilot Studio.

Definition (OpenAPI 2.0 / Swagger):

{
  "swagger": "2.0",
  "info": { "title": "My API", "version": "1.0" },
  "host": "api.example.com",
  "basePath": "/v1",
  "schemes": ["https"],
  "securityDefinitions": {
    "oauth2": {
      "type": "oauth2",
      "flow": "accessCode",
      "authorizationUrl": "https://login.example.com/authorize",
      "tokenUrl": "https://login.example.com/token",
      "scopes": { "read": "Read access" }
    }
  },
  "paths": {
    "/items": {
      "get": {
        "summary": "List items",
        "operationId": "ListItems",
        "produces": ["application/json"],
        "responses": {
          "200": {
            "description": "Success",
            "schema": {
              "type": "array",
              "items": { "$ref": "#/definitions/Item" }
            }
          }
        }
      }
    }
  }
}

Auth types: API Key, Basic, OAuth 2.0 (authorization code, client credentials), Azure AD.

Policy templates: Set Host URL, route request, set header, convert JSON to object.

Component Libraries

Reusable canvas component libraries allow you to build controls once and share across multiple apps:

• Canvas components: Custom controls with input/output properties, built with the same Power Fx formulas.
• Input properties: Parameters passed into the component (e.g., ItemColor, DataSource).
• Output properties: Values emitted from the component (e.g., SelectedItem).
• Behavior properties: Actions triggered by events (e.g., OnSelect, OnChange).

Component libraries are stored as Dataverse solutions and can be published to the tenant.

Responsive Design

Canvas apps support responsive layouts using container controls:

• Horizontal container: Lay out children side by side.
• Vertical container: Stack children vertically.
• Flexible height/width: Use LayoutMinWidth and LayoutMinHeight for responsive breakpoints.
• Fill portions: Allocate space proportionally among siblings.

Solution Checker

The Power Apps Solution Checker runs static analysis to identify performance issues, security vulnerabilities, and design anti-patterns. Key rule categories:

• Performance: N+1 queries, unbounded loops, missing delegation warnings.
• Security: Hardcoded credentials, insecure HTTP connections.
• Reliability: Unhandled errors, missing required fields.
• Maintainability: Unused variables, overly complex formulas.
• Web API: Deprecated API usage, incorrect metadata.

Run via pac solution check --path <solution.zip> or via the Power Platform admin center.

Power Apps Management REST API

The Business Application Platform (BAP) API provides environment and app lifecycle management outside of the maker portal.

Base URL: https://api.bap.microsoft.com/providers/Microsoft.BusinessAppPlatform

Headers: Authorization: Bearer <token>, api-version: 2016-11-01

Create environment body:

{
  "location": "unitedstates",
  "properties": {
    "displayName": "Dev Sandbox",
    "environmentSku": "Sandbox",
    "linkedEnvironmentMetadata": {
      "type": "Dynamics365Instance",
      "securityGroupId": "<aad-group-id>"
    }
  }
}

Environment SKU values: Production, Sandbox, Trial, Developer.

Dataverse Web API for App Data

The Dataverse Web API provides REST-based CRUD operations on Dataverse tables — the data layer behind model-driven and canvas apps.

Base URL: https://{org}.api.crm.dynamics.com/api/data/v9.2

Create record example:

POST /api/data/v9.2/accounts
{
  "name": "Contoso Ltd",
  "telephone1": "555-0100",
  "address1_city": "Seattle",
  "primarycontactid@odata.bind": "/contacts(00000000-0000-0000-0000-000000000001)"
}

Update record example:

PATCH /api/data/v9.2/accounts(00000000-0000-0000-0000-000000000002)
{
  "telephone1": "555-0200",
  "address1_city": "Redmond"
}

OData query options: $select, $filter, $orderby, $top, $skip, $expand, $count.

Example: GET /accounts?$select=name,telephone1&$filter=address1_city eq 'Seattle'&$top=50

Permissions and Scopes

Token acquisition uses @azure/identity with ClientSecretCredential or InteractiveBrowserCredential. The {org} placeholder is the Dataverse organization URL (e.g., contoso.crm.dynamics.com).

HTTP Error Handling

Dataverse error responses follow this structure:

{
  "error": {
    "code": "0x80040265",
    "message": "The specified record was not found or you do not have permission."
  }
}

Common Patterns

Multi-Step Canvas Form with Offline Collection

Build a multi-screen form that collects data offline and syncs on connectivity:

1. Create a colPendingRecords collection on app start with ClearCollect.
2. Each form screen writes to the collection via Collect(colPendingRecords, {Field1: txt1.Text, ...}).
3. A "Submit All" button iterates with ForAll(colPendingRecords, Patch(DataSource, Defaults(DataSource), ThisRecord)).
4. Wrap each Patch in IfError to track failures: Collect(colErrors, {Record: ThisRecord, Error: FirstError.Message}).
5. Show a summary screen with success count and error table.
6. Use Connection.Connected to check connectivity before submission.

Model-Driven App with Custom Business Process Flow

Build a model-driven app for a multi-stage approval workflow:

1. Create a Dataverse table (e.g., cr_expense_request) with status columns for each stage.
2. Define a Business Process Flow with stages: Submission → Manager Review → Finance Approval → Completed.
3. Add branching logic: if amount > $5,000, route to VP Approval stage before Finance.
4. Configure each stage with required fields (justification, receipt attachment, approval notes).
5. Add a Business Rule to lock the Amount field after Submission stage completes.
6. Use a Real-time Workflow or Power Automate flow to send email notifications on stage transitions.

PCF Control with Dataverse Web API

Build a custom PCF (PowerApps Component Framework) control:

1. Scaffold with pac pcf init --namespace Contoso --name MapPicker --template field.
2. Define the manifest (ControlManifest.Input.xml) with input properties: latitude, longitude, zoomLevel.
3. In index.ts, implement init() to render a map container, updateView() to re-center on property changes, and getOutputs() to return the selected coordinates.
4. Use this.context.webAPI.retrieveMultipleRecords("account", "?$select=name,address1_latitude,address1_longitude&$top=100") to fetch nearby records.
5. Build with npm run build, test with npm start watch, and package with pac pcf push --publisher-prefix cr.

App Creation Workflows

Source Format Note

The current Power Apps canvas source format is .pa.yaml (Source Code v3.0). The older .fx.yaml format is retired. New apps should always use .pa.yaml with Power Platform Git Integration. See references/canvas-app-source.md for the full schema reference.

Decision Tree — Which Command to Use

Want to create a Power App?
├── Canvas app (custom UI)?
│   ├── Have a data source schema? → /pa-app-from-data
│   ├── Know the app pattern?     → /pa-app-create --template <type>
│   │   ├── CRUD (list/detail/edit)    → --template crud
│   │   ├── Dashboard with KPIs        → --template dashboard
│   │   ├── Approval workflow           → --template approval
│   │   ├── Side-by-side master/detail  → --template master-detail
│   │   └── Empty starting point        → --template blank
│   └── Need a single screen?    → /pa-canvas-screen
├── Model-driven app (Dataverse UI)?
│   └── /pa-mda-create --template crud|service-desk
└── Ready to deploy?
    └── /pa-deploy canvas|solution

Canvas App Creation Workflow

1. Scaffold — Use /pa-app-create to generate the project directory with .pa.yaml files. Choose a template that matches your use case.
2. Customize — Edit individual screens with /pa-canvas-screen. Add formulas with /pa-formula. Create components with /pa-component-create.
3. Validate — Run pac canvas validate --path ./src to check for errors.
4. Deploy — Use /pa-deploy canvas to pack and import, or push to the connected Git branch for Git Integration sync.

Model-Driven App Creation Workflow

1. Scaffold — Use /pa-mda-create to generate the solution with sitemap, forms, views, and optional BPF/business rules.
2. Customize — Edit forms with /pa-model-driven-form. Add custom connectors with /pa-connector-create.
3. Validate — Run /pa-solution-checker to check for issues.
4. Deploy — Use /pa-deploy solution to pack and import to the target environment.

Best Practices

• Delegation first: Design data access patterns to be delegable. Use Dataverse as the primary data source for the best delegation support.
• Minimize data calls: Use ClearCollect on app start for reference data, then filter collections locally.
• Concurrent loading: Use Concurrent() in App.OnStart to load multiple data sources in parallel.
• Component reuse: Build component libraries for common UI patterns (headers, sidebars, data cards).
• Naming conventions: Use prefixes — scr for screens, btn for buttons, gal for galleries, txt for text inputs, lbl for labels, ico for icons.
• Error handling: Wrap data operations with IfError and show Notify messages to users.
• App.Formulas: Use App.Formulas (named formulas) instead of App.OnStart for declarative data loading — they're recalculated automatically and improve app startup time.

Reference Files

Example Files

Progressive Disclosure — Reference Files