Microsoft PL-400: Understanding the Exam Blueprint

The PL-400 exam retired on October 30, 2026. New PL-400 registration closed on October 16, and Microsoft now requires AB-400 for new Power Platform Developer Associate candidates. This article preserves PL-400’s exam blueprint as historical context; it is not the skills-measured outline for anyone registering for AB-400 today.

The retired PL-400 exam measured six domains: Create a technical design 10–15%, Configure Microsoft Dataverse 15–20%, Create and configure Power Apps 10–15%, Extend the user experience 10–15%, Extend the platform 35–40%, and Develop integrations 5–10%. Microsoft requires a passing score of 700. AB-400, available since October 16, has four active domains: Build solutions 15–20%, Extend the user experience 25–30%, Extend Power Platform 35–40%, and Develop integrations 10–15%. Those are different from the historical PL-400 weights above.

PL-400 is a developer exam, not a maker fundamentals exam

Microsoft describes the candidate as someone who designs, develops, tests, secures, and troubleshoots Power Platform solutions using extension points. Expected experience includes JavaScript, JSON, TypeScript, C#, HTML, RESTful Web APIs, Power Platform services, and Azure.

A Power Platform Developer preparation plan should therefore include real coding and Dataverse extension work, not only canvas-app design or flow templates.

Create a technical design is 10–15%

The design area covers analyzing requirements, choosing solution components, identifying where low-code is sufficient, selecting extension points, designing security and authentication, considering integration and ALM, and deciding where business logic should run.

The key skill is placement: client script, Power Fx, cloud flow, plug-in, custom connector, Azure service, or another extension can all implement logic, but they have different performance, security, lifecycle, and maintenance implications.

Configure Microsoft Dataverse is 15–20%

Dataverse is the platform core for data, metadata, security, business logic, events, and APIs. Developers should be comfortable with tables, columns, relationships, alternate keys, security, solutions, environment variables, and how Dataverse behavior changes across managed or unmanaged solution layers.

The developer perspective goes beyond creating a table: schema and security choices affect plug-ins, client scripts, integrations, flows, and deployment.

Create and configure Power Apps is 10–15%

This area covers building and extending canvas or model-driven experiences and applying developer skills where low-code features need enhancement. The developer should understand how app components interact with Dataverse, connectors, business logic, and lifecycle management.

An understanding of Power Apps is assumed, but PL-400 expects extension depth rather than beginner maker skills.

Extend the user experience is 10–15%

Client scripting and Power Apps Component Framework are central here. Developers should understand the model-driven Client API, event handlers, Dataverse Web API calls from client code, commands/buttons, navigation, dialogs, notifications, and PCF component lifecycle and packaging.

PCF exists when standard controls or low-code components cannot meet the user-experience requirement cleanly.

Extend the platform is the largest domain at 35–40%

The largest live domain includes Dataverse plug-ins, custom APIs, platform APIs, Organization Service, Dataverse Web API, authentication, API-limit handling, Azure Functions, Power Automate cloud flows, custom connectors, and integration patterns around Dataverse events.

This weighting is the clearest signal that PL-400 is about extending the platform through code and services, not simply configuring Power Platform features.

Plug-ins and server-side logic are high-value skills

Developers should understand Dataverse event pipeline stages, execution context, entity images, synchronous versus asynchronous considerations, performance, transaction behavior, registering plug-ins, and designing custom APIs or business events.

The exam can test why server-side logic is preferable when validation must occur regardless of which client calls Dataverse.

Develop integrations is 5–10%

The integration area covers publishing and consuming Dataverse events, webhooks or Azure messaging endpoints, change tracking, alternate keys, upsert, and custom connectors. The developer should understand reliable synchronization and how external systems exchange data with Dataverse.

Integration questions often test consistency, retry, duplicate handling, authentication, and which platform event or API should be used.

The PL-400 to AB-400 transition is a real date boundary

The current AB-400 outline reorganizes the former domains, adds code-app and agentic AI content, expands user-experience weight, and raises integration weight. These newer requirements belong to AB-400. The six PL-400 categories above remain a record of the predecessor exam, not a current registration or study recommendation.

A PL-400 skills plan should therefore be explicitly dated. Do not mix pre-transition and post-transition percentages in the same final notes.

Current AB-400 preparation includes code apps, agents, and extension depth

Spend the most time on plug-ins, APIs, custom connectors, Power Automate expressions, client scripting, PCF, Azure Functions, ALM, and Dataverse design. Then compare every exercise against the currently published AB-400 objectives; the historical PL-400 appointment window has closed.

The former PL-400 exam page and the updated developer study guide describe different periods of the credential. Current candidates should follow the active AB-400 skills measured and use the predecessor exam’s framework only when comparing legacy learning material with current developer work.

The certification role itself is broader than the old percentages suggest. Microsoft’s current developer-associate page now mentions complex Power Fx, Power Automate expressions, Power Platform CLI, AI tools, and modern IDEs. Those capabilities are relevant to real work and to the transition, but the pre-October-16 PL-400 exam still reports its legacy domain structure.

Technical-design questions often revolve around boundaries. Client-side code can improve form behavior but should not enforce a critical rule by itself. Plug-ins can enforce Dataverse-side logic but may not be appropriate for a long-running external calculation. Power Automate provides orchestration, while Azure Functions provide code execution outside the Dataverse transaction.

Authentication and authorization should be part of design from the start. External integrations may use OAuth, service principals, managed identities, or other supported patterns depending on the component. The developer should avoid embedding user credentials or secrets in code and should scope privileges to the operations actually required.

Dataverse solution architecture also includes standard versus custom tables, choice of relationships, alternate keys, virtual-table patterns where applicable, and data ownership. A poor table design can create performance or integration problems that no amount of client scripting can fix later.

Solution layers and dependencies matter because Power Platform customizations can come from Microsoft, managed solutions, unmanaged development work, or patches/upgrades. Developers should know which layer owns the effective component and avoid changes that create unexpected dependency or upgrade conflicts.

Environment variables and connection references help separate configuration from solution logic. A flow or integration should not require editing hardcoded development URLs or credentials after import into test or production. ALM succeeds when environment-specific values are injected through supported configuration.

Power Apps development in PL-400 assumes more than creating controls. Developers may need to optimize formulas, manage delegation constraints, work with custom components, and integrate client-side or server-side behavior. The exact live domain wording is older, but the expected practitioner level remains technical.

Client API code should be written defensively because forms can change, fields can be missing, and asynchronous calls can fail. Registering event handlers deliberately and keeping JavaScript modular makes model-driven extensions easier to test and support than a large script attached to every form event.

PCF components should expose clearly defined inputs and outputs and use platform services rather than bypassing the app model unnecessarily. Packaging the component in solutions allows controlled deployment. The developer should weigh the benefit of custom interaction against the maintenance burden of custom code.

Plug-in performance is critical because synchronous logic can delay user transactions. Developers should avoid unnecessary service calls, large queries, or recursive updates and should move long-running or noncritical processing to asynchronous patterns when appropriate.

Custom APIs can provide a governed Dataverse operation that clients or integrations invoke consistently. They are useful when a business operation is more meaningful than a sequence of raw table updates and when server-side validation should remain centralized.

API-limit handling is another practical developer skill. Dataverse can throttle requests under heavy load, so integrations should implement retry patterns and avoid inefficient row-by-row operations when batch or bulk approaches are available. Correctness without scalability can still produce a failing production solution.

Azure Functions can process work that does not belong inside a Dataverse plug-in transaction, such as scheduled integration, external API orchestration, or longer-running processing. The developer should still design authentication, retry, telemetry, and idempotency because moving logic to Azure does not remove failure modes.

Power Automate expressions and error handling matter in developer-grade flows. Complex conditions, retry policies, child flows, trigger filters, and service-principal authentication can turn a maker-style workflow into a reusable solution component. The exam may present a flow that requires more discipline than a simple notification.

Dataverse event integrations should be designed for eventual failure. Webhooks, Service Bus, or Event Hub endpoints may be unavailable temporarily; consumers may receive duplicate or delayed messages; and data may change between event publication and processing. Reliable integrations anticipate these conditions.

Change tracking and alternate keys help synchronization with external systems. A stable alternate key lets an integration find the same business record across systems, while change tracking reduces the need to query every row. Upsert can simplify create-or-update behavior when the external identifier is reliable.

Custom connectors wrap existing APIs for use in Power Apps and Power Automate. A good connector defines authentication, operations, request/response schemas, and policy behavior clearly. It should not be used to hide a poorly designed API that lacks stable contracts or error semantics.

For any new exam attempt after October 30, 2026, register for AB-400 and study its current four-domain objectives, including code apps and agent integrations. The historical PL-400 six-domain percentages shown in this article are useful only for understanding the retired exam and for transferring enduring Dataverse, plug-in, API, and integration skills.

Within the wider Microsoft certification portfolio, the retired PL-400 exam historically validated Power Platform developer skills, while AB-400 is the current required exam for the Power Platform Developer Associate credential. Knowing which outline applies prevents a misleading preparation plan.