Dynamics 365 Power Platform Certification

Design solutions by selecting appropriate Power Platform components based on business scenarios and technical constraints.

Analyze trade-offs between Dataverse and external data sources (e.g., SharePoint, SQL) to select the appropriate data store.

Design a security model for a multi-tenant scenario using environments, business units, and security roles.

Design a Dataverse data model, selecting appropriate relationship types and behaviors to enforce business logic and optimize performance.

Implement complex data structures in Dataverse using polymorphic lookups and hierarchical relationships.

Identify and plan for developer-relevant licensing constraints (e.g., premium connectors, API limits, Dataverse capacity).

Compare and contrast the use of unmanaged and managed solutions for application lifecycle management.

Explain the concept of solution layers and the merge behavior of solution components.

Evaluate synchronous vs. asynchronous plugin execution and select appropriate pipeline stages for business requirements.

Implement batch operations to improve performance using ExecuteMultipleRequest.

Ensure data consistency across multiple operations using ExecuteTransactionRequest.

Handle exceptions and implement retry logic in plugin development.

Configure and use alternate keys for external system integrations.

Configure plugin pre-images and post-images for efficient access to record data.

Design Canvas Apps with structured navigation patterns using Navigate, Back, and deep linking.

Connect a Canvas App to Dataverse and external tabular data sources like SharePoint and SQL Server.

Perform CRUD operations on data sources using Power Fx functions like Patch, Filter, and LookUp.

Manage app state and temporary data using collections and variables.

Implement bulk data operations by combining the ForAll and Patch functions.

Implement input validation on user entry fields using Power Fx functions like IsMatch and IsBlank.

Implement error handling for data source operations and formulas using the IfError and Errors functions.

Design responsive Canvas App layouts using containers and modern screen templates.

Create and use a Power Apps component library to build reusable UI components.

Implement offline capabilities in a Canvas App using collections, LoadData/SaveData, and data synchronization patterns.

Integrate Canvas Apps within Model-driven Apps using embedding and context passing.

Debug and analyze Canvas App performance using the Monitor tool.

Integrate a Canvas App with Application Insights for custom telemetry and analytics.

Consume data from a pre-built custom connector within a Canvas App.

Implement complex formulas combining Filter, LookUp, and With functions for advanced scenarios.

Design Model-driven Apps applying modern best practices for app modules, site maps, and user experience.

Evaluate the trade-offs between business rules and JavaScript for implementing client-side logic.

Use Xrm.WebApi for client-side CRUD operations in Model-driven App forms.

Develop and bundle client-side logic using TypeScript for improved type safety and maintainability.

Customize the app command bar for tables and forms using the modern command designer.

Implement business process flows with stages, steps, and branching logic.

Create custom pages in Model-driven Apps to provide tailored user experiences.

Implement reusable JavaScript web resource libraries to share functions across multiple form scripts.

Implement cloud flows triggered by events in Dataverse, SharePoint, and other services.

Use expressions and built-in functions for data transformation within a flow.

Implement control flow logic using conditions, switch cases, and apply-to-each loops.

Configure robust error handling using scopes, 'configure run after' settings, and try-catch patterns.

Implement parallel branches and join operations for concurrent processing.

Create and call child flows to build modular and reusable automation logic.

Implement a standard approval workflow using the Power Automate Approvals connector.

Modify an approval workflow to use dynamic approvers retrieved from a Dataverse table.

Use the HTTP action to call external REST APIs with various authentication methods.

Create a custom connector for a REST API using API Key or Basic authentication.

Configure OAuth 2.0 authentication for a custom connector to securely connect to a third-party service.

Define actions, triggers, and parameters in a custom connector definition.

Implement policy templates to modify the behavior of a custom connector at runtime.

Create a desktop flow using Power Automate for Desktop to automate a UI-based task.

Integrate a desktop flow with a cloud flow, passing input and output parameters.

Describe the differences in triggers, actions, and licensing between Power Automate and Azure Logic Apps.

Design chatbot topics with trigger phrases, conditions, and conversation nodes.

Manage conversation state using variables and extract user information with entities.

Integrate Copilot Studio with Power Automate flows to perform backend actions.

Use generative actions to create dynamic responses by connecting to data sources like websites or SharePoint.

Extend Copilot Studio capabilities with plugin actions built from custom connectors or Power Automate flows.

Test, debug, and publish a chatbot to a channel like a custom website.

Monitor and analyze chatbot performance and user conversations to identify areas for improvement.

Select the appropriate AI Builder model type for a given business problem (e.g., prediction, form processing, object detection).

Create and train a custom AI Builder form processing model to extract data from documents.

Train a custom AI Builder object detection model using a custom image dataset.

Evaluate and improve AI model performance using test data and performance metrics.

Integrate a trained AI Builder model into a Power App to process user input or images.

Integrate a trained AI Builder model into a Power Automate flow to automate document or text processing.

Use the prebuilt text recognition AI model in a flow to extract text from an image.

Use the prebuilt key phrase extraction AI model in an app to analyze user-provided text.

Install the Power Platform CLI and initialize a PCF component project.

Implement the init and updateView methods to render the component and respond to data changes.

Implement the getOutputs and destroy methods to return data to the host and perform cleanup.

Bind PCF components to field and dataset properties within a Model-driven or Canvas App.

Use the ComponentFramework.WebApi to perform CRUD operations against Dataverse data from within a component.

Style PCF components using CSS and responsive design principles.

Build, test, and debug PCF components locally using the local test harness.

Package and deploy a PCF component as part of a Dataverse solution.

Configure Azure Service Bus for asynchronous, event-driven integration with Dataverse.

Register and configure a webhook to call an external service from a Dataverse event.

Develop a C# Azure Function to process data received from a Dataverse webhook or Service Bus message.

Develop an Azure Logic App to orchestrate a business process involving Power Platform and other Azure services.

Choose an appropriate integration technology (Custom Connector, Webhook, Service Bus, Logic Apps) for a given scenario.

Secure API calls between Power Platform and Azure using Azure AD app registrations and managed identities.

Implement a pattern for synchronizing data between Dataverse and an external Azure SQL database.

Monitor and troubleshoot integrations using Application Insights and Azure Monitor.

Implement connection references and environment variables for deployment flexibility across environments.

Use the 'See solution layers' feature to troubleshoot component conflicts and unexpected behavior.

Use the Power Platform CLI to pack, unpack, and manage solution files.

Create a build pipeline in Azure DevOps to automate the export and packing of a managed solution.

Create a release pipeline in Azure DevOps to automate the deployment of a managed solution to a target environment.

Incorporate automated solution checking using the Power Apps Checker into a build pipeline.

Develop an environment and branching strategy for team-based Power Platform development.