Study guide

1.4 Designing Reusable Power Apps Components and Custom Connectors

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

1.4 Designing Reusable Power Apps Components and Custom Connectors

Key Takeaways Explain This Topic AI

Canvas components with custom properties, packaged into component libraries, provide versioned reuse across canvas apps only.

PCF code components are the only reuse mechanism that works across both canvas apps and model-driven app forms, and support field or dataset rendering.

Client scripting should be organized into shared, parameterized web resource libraries rather than duplicated per form.

A custom connector is required whenever a solution must call an external REST API with no existing standard or premium connector.

Custom connector design decisions include the OpenAPI definition source, authentication type, policy templates for runtime request/response transformation, and DLP group impact.

Last updated: July 2026

Reusability is a core architectural goal on PL-400: a well-designed component should be built once and consumed across many apps and forms, instead of being re-implemented every time a similar UI need appears. This section covers the three reuse mechanisms available for Power Apps UI, plus how to design a custom connector when no existing connector reaches a required external API.

Canvas Components and Component Libraries

A canvas component is a reusable grouping of controls — a custom card, a rating control, a navigation header — built once inside a canvas app and packaged with custom properties (input properties that configure it, output properties that expose its state back to the consuming screen). Publishing a component to a component library makes it available across multiple canvas apps in the same environment, so a design system (branded buttons, standard headers, validation banners) can be centrally maintained and versioned.

Key design considerations for canvas components:

Components in a library are versioned ; consuming apps must explicitly update to a new version, which protects existing apps from unexpected breaking changes.

Components are limited to canvas app surfaces — they cannot be used inside a model-driven app form.

Complex custom rendering (charts with unusual interactivity, camera/barcode integrations beyond built-in controls) still may exceed what a canvas component can express, pointing toward a PCF code component instead.

Code Components (PCF)

A Power Apps component framework (PCF) code component is a professionally coded (TypeScript/HTML/CSS) control that can be used as either a field component (renders a single column) or a dataset component (renders a grid/list of records), and — unlike a canvas component — works in both canvas apps and model-driven app forms and views. PCF is the right design choice when a requirement needs rich, highly interactive UI (a custom map, a Gantt chart, a signature pad) that exceeds what canvas controls or components can render, or when a control must be reused across both canvas and model-driven surfaces.

Reusable Client Scripting

JavaScript logic for model-driven forms should be organized into web resource libraries — shared .js files referencing named functions — rather than duplicated inline per form. A well-designed library exposes generic, parameterized functions (e.g., a single "required field" validator configured per form via event handler parameters) so the same script is registered across many forms and tables instead of being copy-pasted with small variations.

  • Reuse mechanism Where it works Best for
  • Canvas component / component library Canvas apps only Branded UI patterns, reusable input groups
  • Code component (PCF) Canvas apps and model-driven apps Rich custom controls, grid/list rendering
  • Client scripting library Model-driven forms Shared validation and form-behavior logic
  • Designing Custom Connectors

When a requirement needs to call an external REST API that has no existing standard or premium connector , the solution is a custom connector . Designing one involves several decisions made up front:

Definition source — build the OpenAPI (Swagger) definition manually, import it from an existing OpenAPI file, or generate it from a sample Postman collection.

Authentication type — an API key, Basic authentication, or OAuth 2.0 (the connector stores the client ID/secret and token endpoint so users don't manage tokens themselves).

Host and base URL — the connector's root endpoint, with individual actions and triggers defined against it as HTTP operations (GET, POST, etc.).

Policy templates — reusable transformations applied to requests/responses at runtime without modifying the underlying API — for example, setting a fixed header, mapping a query parameter, or transforming a response's content type. Policy templates let a connector adapt to platform requirements without needing changes on the API side.

Sharing and lifecycle — a custom connector can stay personal to its creator or be shared/published through a solution so other makers in the environment (and, when the solution is deployed, other environments) can add it to their flows and apps.

Because a custom connector's data classification also participates in DLP policy grouping (covered in the previous section), its design should account for which DLP group it will fall into so it isn't blocked from combination with connectors it needs to work alongside in a flow.

Putting It Together

A typical PL-400 scenario asks you to choose between these options for the same UI problem. If the requirement is confined to canvas apps and is primarily visual composition, a canvas component is the lightest option. If it must also appear on a model-driven form, or needs behavior beyond what Power Fx can express, PCF is the correct answer. And whenever the requirement is "call this external API," the answer is a custom connector, not a plug-in or Azure Function — those are for logic that runs inside Dataverse's own pipeline, not for exposing an API to makers as a reusable action.