This module establishes the professional development workflow for Power Platform: environment usage, solution-based development, and the tooling required to extend the platform with code.

Lessons:

• Developer role responsibilities and extension scenarios

• Environment strategy for development and release readiness

• Solution-based development fundamentals (components, packaging, dependencies)

• Installing and configuring developer tools (Power Platform CLI, IDEs, utilities)

• Using migration and community tools to support delivery workflows

Key Topics:

• Developer workflow and solution-centric delivery

• Environment separation and release discipline

• Toolchain setup for pro-code development

• Data/configuration movement between environments

Labs / Practical Exercises (if applicable):

• Configure developer tools and validate environment connectivity

• Export/import reference data between environments using migration tooling 

This module builds advanced canvas app capability, focusing on scalable patterns, data operations, and integrating automations for business logic.

Lessons:

• Advanced Power Fx patterns for data updates and control logic

• Delegation-aware data access and performance considerations

• Working with relationships and data shaping for app UX

• Calling automations from canvas apps to enforce business rules

• Testing and troubleshooting canvas app behavior

Key Topics:

• Complex formulas and update patterns (e.g., Patch-based writes)

• Reusable app patterns and maintainability

• App-to-flow integration for business logic

• Performance and troubleshooting fundamentals

Labs / Practical Exercises (if applicable):

• Implement advanced record updates using formula-driven logic

• Integrate an automation call to complete a business step 

This module covers developer-grade automation design using cloud flows, including scheduled patterns, app-triggered flows, Dataverse actions, and robust flow logic.

Lessons:

• Selecting the correct trigger type (scheduled vs. instant/app-triggered)

• Using Dataverse actions effectively (list rows, update row, get row)

• Implementing expressions, choice handling, and dynamic content

• Building reusable automation patterns and controlled responses to apps

• Error handling and operational considerations

Key Topics:

• Developer automation patterns and governance readiness

• Dataverse integration in flows

• Expression-based logic and flow reliability patterns

• Secure handling of inputs/outputs in automations

Labs / Practical Exercises (if applicable):

• Build a scheduled flow that queries and updates Dataverse records

• Build an instant flow triggered from a canvas app and return a response 

This module introduces programmatic access to Dataverse using supported APIs and development approaches, enabling custom logic, bulk operations, and advanced troubleshooting.

Lessons:

• Dataverse API landscape and when to use each approach

• Organization service fundamentals and connection strategies

• Building a .NET client application for Dataverse data operations

• Authentication concepts for secure access

• Performance considerations for API-based operations

Key Topics:

• Organization service usage patterns

• API connectivity and authentication fundamentals

• Operational reliability and troubleshooting for API calls

• Development practices for maintainable integrations

Labs / Practical Exercises (if applicable):

• Create a .NET console application and connect to Dataverse using the organization service

• Perform initial metadata/data operations as a foundation for later extensions

This module focuses on enhancing model-driven apps through client-side logic, Dataverse Web API usage, and command customization aligned to modern UX and business requirements.

Lessons:

• Client API fundamentals and event handler design

• Implementing web resources and registering scripts on forms

• Using Dataverse Web API from client scripts for contextual logic

• Dynamically controlling form UI (visibility, required fields, navigation)

• Customizing command bars and invoking custom APIs from commands

Key Topics:

• Client scripting architecture and maintainability

• Web API usage for UX-driven data evaluation

• Command customization patterns for productivity

• Form behavior governance and safe extension approaches

Labs / Practical Exercises (if applicable):

• Build form logic that retrieves related records and updates UI behavior

• Add a command that calls a custom API endpoint for a business action 

This module teaches how to create and deploy reusable code components with PCF, enabling fully controlled UI experiences and optimized interactions for model-driven apps.

Lessons:

• PCF fundamentals and component lifecycle

• Initializing components using Power Platform CLI

• Implementing component logic using TypeScript

• Packaging and publishing components for use in solutions

• Adding and configuring components on model-driven forms

Key Topics:

• PCF component lifecycle and interfaces

• Manifest configuration and data binding concepts

• Packaging, deployment, and solution integration

• Component reusability and UX consistency

Labs / Practical Exercises (if applicable):

• Build a PCF control, publish it, and configure it on a form as a reusable UX component 

This module covers server-side extensibility with plug-ins and custom APIs, including event-driven business logic, registration, deployment, and trace-based troubleshooting.

Lessons:

• Plug-in fundamentals: events, pipeline stages, and execution context

• Implementing business logic for table events (create/update)

• Building and registering plug-ins for custom APIs

• Deployment strategies and associating plug-ins with solutions

• Using plug-in trace logs for diagnostics and performance tuning

Key Topics:

• Plug-in pipeline design and execution context

• Custom API extensibility patterns

• Deployment and registration practices

• Troubleshooting using trace logs and instrumentation

Labs / Practical Exercises (if applicable):

• Create a plug-in that validates business constraints during record creation

• Register a plug-in step for a custom API and validate end-to-end execution

This module enables enterprise integration by connecting Dataverse and Power Platform solutions to Azure services and external APIs through events, webhooks, Azure Functions, and custom connectors.

Lessons:

• Integration patterns: event publishing and webhook-based processing

• Building Azure Functions for event-driven and long-running workloads

• Configuring Dataverse to publish events to external endpoints

• Creating custom connectors to make APIs consumable in Power Apps and Power Automate

• Securing and testing custom connectors and app usage

Key Topics:

• Dataverse event publishing and external processing

• Azure Functions for scalable workloads and integrations

• Custom connectors and API abstraction for makers and developers

• Integration testing and operational readiness

Labs / Practical Exercises (if applicable):

• Create an Azure Function endpoint and configure Dataverse to publish events via webhook

• Build a custom connector backed by an Azure Function and consume it from an app