Microsoft Power Platform Developer

Code that touches data must prove who it is and be limited to what it needs. You register applications in Entra, use service principals and application users, and shape security roles, business units and field-level security.

• App registrations for Dataverse access
• Application users and service principals
• Security roles, business units and teams
• Field-level security
• Acquiring tokens for the Web API
• Keeping secrets out of code

You build A registered app with an application user, a least-privilege security role and a working token request.

Code and configuration have to move between environments without breaking. You package work in solutions, manage layers and environment variables, and automate release with Power Platform Pipelines and Build Tools.

• Managed and unmanaged solutions
• Solution layers and how conflicts resolve
• Environment variables and connection references
• Source control for solutions
• Power Platform Pipelines
• Build Tools in an Azure DevOps or GitHub workflow

You build A release process that moves a solution from development to production through a pipeline.

Client scripting adds behavior the form designer cannot. You write JavaScript and TypeScript against the Client API, react to form events, call Dataverse from the form, and extend the command bar.

• The form context and the Client API
• Form, field and save events
• Reading and writing data with Xrm.WebApi
• Command bar buttons and visibility rules
• TypeScript, bundling and unit testing
• Debugging scripts in the browser

You build A set of form scripts that validate data and fill related fields, written in TypeScript and tested.

When a built-in control falls short, you build your own. You create PCF components in TypeScript, bind them to data, handle their lifecycle, and package and deploy them to apps.

• Component manifest, properties and datasets
• The component lifecycle: init, update and destroy
• Rendering with TypeScript and React
• Calling the platform from a component
• Packaging, deploying and updating components

You build A PCF component deployed in a solution and used on a form.

Code apps let developers build full web apps that run inside Power Platform. You learn when that fits better than a canvas app or a component, build one in a TypeScript project, connect it to data, and deploy and monitor it.

• When a code app is the right choice
• Setting up a code app project
• Connecting a code app to data sources
• Deploying a code app to an environment
• Monitoring a code app in use
• Comparing code apps, canvas apps and PCF

You build A small code app deployed to a test environment, with a note on why it was built this way.

Plug-ins run business logic inside the platform’s event pipeline, where mistakes hit every user. You write them in C#, choose the stage and mode, handle images and context, and debug them with tracing.

• The event execution pipeline and its stages
• Writing a plug-in in C# with IPlugin
• Pre-images, post-images and the execution context
• Synchronous and asynchronous plug-ins
• Registering plug-in assemblies and packages
• Tracing and debugging
• Avoiding infinite loops and slow plug-ins

You build A tested plug-in that enforces a business rule on create and update, registered through a solution.

Everything outside the platform reaches Dataverse through its APIs. You query and change data with the Web API, use batch requests and FetchXML, and define custom APIs that expose your own operations.

• OData queries and the Web API
• Creating, updating and deleting rows
• Batch requests and FetchXML
• Actions and functions
• Defining a custom API
• Handling throttling and retries

You build A client that reads and writes Dataverse through the Web API, plus a custom API with a plug-in behind it.

Some work is too slow or too large for a plug-in or a flow action. You offload it to Azure Functions, call functions from flows and plug-ins, and shape cloud flows so they run reliably at volume.

• When to move work out of the platform
• Writing an Azure Function that calls Dataverse
• Calling a function from a cloud flow
• Flow design for volume: concurrency, paging and retries
• Authenticating functions with managed identities

You build A cloud flow that hands a long-running job to an Azure Function and writes the result back to Dataverse.

Agents add reasoning to business processes, and they need careful tools and limits. You build an agent in Foundry, give it Power Platform actions and data to work with, and test how it behaves before it touches real records.

• What an agent adds to a Power Platform solution
• Building an agent in Foundry
• Giving an agent tools, actions and data
• Guarding what the agent may change
• Testing agent behavior with sample cases
• Calling an agent from flows and apps

You build A Foundry agent that works with Dataverse data through limited tools, with a set of test conversations.

Systems have to talk to each other without losing records. You publish Dataverse events to external services, synchronize data with change tracking and upserts, and wrap your own APIs in custom connectors.

• Publishing events to webhooks and Service Bus
• Consuming Dataverse events in external code
• Change tracking and delta synchronization
• Upserts with alternate keys
• Defining a custom connector from an OpenAPI description
• Authentication and actions in a custom connector

You build A two-way sync between Dataverse and an external service, with a custom connector for that service’s API.

One project uses every layer. You design a solution, build its data and logic, extend the app with scripts, components and code, integrate an outside system, and release it through a pipeline.

• Scoping the solution and choosing layers
• Building the data, logic and security
• Extending the user experience
• Integrating an external system
• Releasing and reviewing the work

You build A complete extended Power Platform solution, released through a pipeline and documented for handover.