Study guide
4.4 PCF Fundamentals: The Component Manifest & Lifecycle Events
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
4.4 PCF Fundamentals: The Component Manifest & Lifecycle Events
Key Takeaways Explain This Topic AI
pac pcf init --template field|dataset scaffolds a component; field binds to one table column, dataset binds to a view or subgrid's records and columns.
ControlManifest.Input.xml declares the control, its bindable properties or data-set, its resources (code/CSS/RESX), and any feature-usage capabilities it needs at runtime.
A component must declare <feature-usage> for WebAPI, Utility, or Device capabilities before it can actually use the corresponding context API.
The lifecycle runs init() once, then updateView() repeatedly as data or size changes, getOutputs() to return pending changes, and destroy() once on removal.
Choosing field vs. dataset at scaffolding time determines the entire shape of the manifest and the component's data-access code.
Last updated: July 2026
The Power Apps Component Framework (PCF) lets pro developers build custom, reusable UI controls — code components — using TypeScript, HTML, and CSS. A code component can replace the default renderer for a single field or an entire dataset (a view or subgrid), and it can run in model-driven apps and, when enabled, canvas apps as well. This section covers how a component is scaffolded and declared, and the lifecycle methods that drive it at runtime.
Scaffolding a Component with the Power Platform CLI
Development starts with the Power Platform CLI ( pac ): pac pcf init --namespace Contoso --name RatingControl --template field
The --template flag chooses between two fundamentally different component shapes:
field — binds to a single table column and renders/edits one value at a time, replacing the default control for that data type.
dataset — binds to a list of records (a view or subgrid) instead of one field, giving the component access to multiple rows and columns at once.
This scaffold produces ControlManifest.Input.xml , an index.ts entry point, and standard package.json / tsconfig.json project files.
The Control Manifest
ControlManifest.Input.xml is the declarative contract between the component and the platform. Its key elements:
- Element Declares
- <control> namespace, constructor (the exported class name), version, display-name-key, description-key
<property> a bindable input/output/bound value — for a field component, exactly one usage="bound" property typically defines the data type the control attaches to
<data-set> for dataset components only — the columns/targets the component binds to when attached to a view or subgrid, replacing a single <property>
<resources> the compiled code bundle, CSS files, and RESX resource strings for localization; can reference shared platform-library resources (e.g., React) instead of bundling them
<feature-usage> platform capabilities the component needs at runtime — WebAPI, Utility, or specific Device features — which must be declared here before the corresponding context API is usable
Omitting a <feature-usage> declaration for a capability the code actually calls at runtime — such as context.webAPI — is a common source of components that behave correctly in the local test harness but fail once packaged, because the manifest is what the platform inspects before granting that access.
Lifecycle Methods
index.ts implements a class satisfying ComponentFramework.StandardControl<IInputs, IOutputs> (or a React-based variant covered in the next section). The platform calls four methods, in this order over the component's life:
init(context, notifyOutputChanged, state, container) — called exactly once when the component first loads. Receives the initial context , stores the notifyOutputChanged callback for later use, restores any previously persisted state , and — for non-React controls — builds the initial DOM inside container .
updateView(context) — called every time bound data changes elsewhere (for example, the field's value is updated by a different control or a business rule) or the container is resized. This is where the component re-renders based on the latest context.parameters values; it can be called many times over the component's life.
getOutputs() — called by the platform to pull the component's current output value(s) after the component has called notifyOutputChanged() to signal a change; the return shape must match the manifest's declared IOutputs .
destroy() — called once when the component is being removed from the DOM, such as when the user navigates away from the form. This is where event listeners, timers, or other resources acquired in init() should be released.
Field vs. Dataset in Practice
A field-type component's manifest binds one <property> to a specific table column data type — for example, a whole number — and context.parameters in init / updateView exposes that single typed value along with formatting and security metadata. A dataset-type component's manifest instead declares a <data-set> , and context.parameters.<datasetName> exposes the bound records, columns, sorted record IDs, and paging as a collection rather than a single value. Choosing the wrong template at pac pcf init time — field when the requirement is really "customize how this subgrid renders" — means rebuilding the manifest and much of the component's data-access code from scratch, which is why PL-400 scenario questions frequently test whether you can identify field versus dataset from the requirement alone before any code is written.
Flexible Typing and Localization
A <property> can bind to a fixed data type (for example, SingleLine.Text ) or to a <type-group> , which lists several compatible types (such as whole number, currency, and decimal) so the same component can be dropped onto any column matching one of those types without a separate manifest per data type. This flexible-typing option is what lets one rating-control component, for instance, be reused across several numeric columns of different subtypes rather than forcing a developer to fork the project for each one.
Localization is handled through the <resources> element's RESX files rather than hardcoded strings in TypeScript: display-name-key and description-key on the control and its properties point at resource keys, and a RESX file per supported language culture supplies the localized text, so the same compiled bundle renders correctly across languages configured in the environment without a code change.
Validating the Manifest
pac pcf build (or the build step inside npm start / npm run build ) compiles index.ts into bundle.js and validates the manifest against the platform's schema, catching mismatches such as a <property> referencing an of-type the framework doesn't recognize, or a missing required attribute, before the component is ever pushed or packaged. Treating this build step as a checkpoint — not just packaging noise — is worth remembering, since manifest errors caught here are far cheaper to fix than the same errors discovered after a solution has already been imported into a downstream environment.