Study guide

2.5 Power Platform Pipelines & CI/CD with Power Platform Build Tools

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

2.5 Power Platform Pipelines & CI/CD with Power Platform Build Tools

Key Takeaways Explain This Topic AI

Power Platform Pipelines lets makers self-serve solution promotion through admin-configured stages directly from the maker portal.

Pipelines can be extended with pre-deployment and post-deployment steps, including calling a Power Automate flow at those points.

Power Platform Build Tools' Unpack Solution task converts a solution zip into individually source-controllable, diffable files for git and code review.

CI/CD service connections should authenticate as a least-privilege application user backed by a service principal, never a named developer's credentials.

The Deploy Package task runs a compiled .NET package for advanced, code-driven deployment logic beyond standard import/export tasks.

Last updated: July 2026

Power Platform Pipelines & CI/CD with Power Platform Build Tools

Quick Answer: Power Platform Pipelines is the low-code, in-product way to promote managed solutions through admin-configured stages from the maker portal, extensible with pre- and post-deployment steps. Power Platform Build Tools is the pro-code way, wrapping pac operations as Azure DevOps or GitHub Actions tasks, with Unpack/Pack Solution enabling git-based source control.

Two Ways to Automate Deployment

This chapter's domain tests two complementary approaches to moving managed solutions through dev, test, and production without manual, error-prone maker-portal exports: the low-code, built-in Power Platform Pipelines, and the pro-code, external Power Platform Build Tools for Azure DevOps and GitHub Actions.

Power Platform Pipelines

Power Platform Pipelines is a first-party, in-product deployment tool. An admin configures a host environment, where the Pipelines app and configuration live, and a set of target environments representing stages such as Development, Test, and Production. Makers then deploy their own solutions through those stages directly from the maker portal, without needing Azure DevOps or admin intervention for every release.

Each pipeline defines an ordered list of stages; a maker with the right permission triggers a deployment run that exports the solution as managed and imports it into the next stage's target environment.

Run history is retained per pipeline so a developer can see what was deployed, when, by whom, and whether it succeeded - useful for both auditing and troubleshooting a bad release.

Pipelines are extensible: a developer can attach pre-deployment and post-deployment steps, including calling a Power Automate flow at those extension points, to run validation, notify a team, or kick off automated tests before or after a stage promotion. This extensibility is what turns the low-code pipeline into a real release-gate mechanism.

Because Pipelines runs inside the Power Platform itself, it's the right recommendation when the requirement is to let citizen developers and pro developers both promote solutions safely without standing up separate DevOps infrastructure.

Power Platform Build Tools (Azure DevOps / GitHub Actions)

For teams already using Azure DevOps or GitHub Actions, the Power Platform Build Tools extension supplies reusable pipeline tasks that wrap the same underlying operations the pac CLI exposes.

  • Task Purpose
  • Export Solution Exports a solution, managed or unmanaged, from a source environment

Unpack Solution Expands the exported zip into individual XML/YAML files suitable for source control - diffable, mergeable

Pack Solution Reverses Unpack; rebuilds the deployable zip from source-controlled files, typically as managed for a release build

Import Solution Imports a packed solution into a target environment

Set Solution Version Bumps the solution version as part of a build, keeping versioning automated and consistent

Publish Customizations Publishes all customizations in the target environment after import

Deploy Package Runs a custom deployment package - a compiled .NET package - for advanced, code-driven deployment logic

Who Am I Validates the pipeline's service connection can authenticate, useful as an early pipeline health check

The unpack/pack pair is the crux of pro-code ALM: it converts a solution from an opaque zip into a folder of individual files that can be committed to git, code-reviewed through a pull request, and diffed component by component - exactly the workflow PL-400 expects a professional developer to use instead of manually exporting zips.

Authentication for CI/CD

Both approaches should authenticate as an application user backed by a service principal or Microsoft Entra app registration, with a Dataverse security role scoped to least privilege, never as a named developer's interactive credentials, which break the pipeline the moment that person's password rotates or they leave the team. The pac CLI itself supports this pattern locally through pac auth create --applicationId --clientSecret --tenant , mirroring how the DevOps or GitHub service connection authenticates.

Choosing Between Them

Use Power Platform Pipelines when the priority is empowering makers and developers to self-serve promotions with minimal setup and native run history, and the organization doesn't already run Azure DevOps for this workload.

Use Power Platform Build Tools when the solution needs source control, code review, automated testing, or integration with a broader software CI/CD process the organization already runs outside the Power Platform.

The two are not mutually exclusive. Some teams unpack, pack, and source-control with Build Tools while still using Pipelines' run history and stage gates for the actual promotion, or trigger a pipeline's post-deployment Power Automate step from a Build Tools release.

Exam Angle

Expect PL-400 to test whether you can recommend the right mechanism for a stated constraint - source control required means Build Tools with unpack/pack; maker self-service without DevOps means Pipelines; needing to gate a promotion on an automated check means pipeline extensibility with a pre- or post-deployment flow - and whether the deployment identity follows least privilege through an application user.