Microsoft Power Platform Developer PL-400 Exam Guide
Exam PL-400 validates whether you can design, develop, test, and troubleshoot Power Platform solution components rather than merely configure a basic app or flow. It is aimed at developers who use Dataverse, Power Apps, Power Automate, integrations, code, and platform extension points to solve business requirements. This guide helps you decide whether your current experience is ready for PL-400, which skills need deliberate practice, how to sequence your preparation, and what to verify before scheduling the assessment.
What PL-400 is designed to validate
PL-400 tests the work of a Power Platform developer across solution design, application development, automation, extension, and integration. Microsoft describes the role as designing, developing, testing, and troubleshooting solution components by using Microsoft Power Platform extension points. That means preparation should connect features to implementation decisions, constraints, security, deployment, and diagnosis.
The certification covers custom user experiences, business logic, system integrations, data conversions, custom process automation, complex Power Fx logic, Power Automate workflow expressions, and AI used as part of solution logic. A candidate should be able to explain not only how to build a component, but why a particular component or extension approach fits the requirement.
This is not a narrow canvas-app examination. The expected knowledge includes Microsoft Power Platform services, authentication, security, application lifecycle management, Power Platform developer tools including Power Platform CLI, and AI tools such as copilots or agents used to improve development and troubleshooting solutions.
Who should consider this exam
The intended audience is a developer working with Power Platform services and related code technologies. The certification is listed as intermediate level for the developer role, while the associated PL-400T00-A course is labeled advanced. Treat those labels as context, not as a substitute for practical readiness: the decisive question is whether you can implement and troubleshoot solutions across the platform.
Microsoft identifies development experience involving JavaScript, JSON, TypeScript, C#, HTML, RESTful Web APIs, Visual Studio, Visual Studio Code, and Microsoft Azure. You do not need to study every technology as an isolated subject. You do need to understand how code, APIs, Azure services, and Power Platform components work together when low-code features alone do not meet the requirement.
The official training course expects foundational Power Platform understanding and hands-on experience with Dataverse data models, tables, columns, relationships, canvas apps, model-driven apps, and Power Automate cloud flows. If several of those are unfamiliar, start with foundational Power Platform learning before moving into exam-specific extension topics.
What the credential means after passing
Microsoft lists the Power Platform Developer Associate certification with a 12-month renewal frequency. The renewal process is separate from initial PL-400 preparation: candidates whose certification will expire within six months are eligible to renew by passing the online renewal assessment on Microsoft Learn.
Microsoft’s renewal resources include extending Dataverse plug-ins, getting started with the Power Apps component framework, client scripting, custom connectors, Dataverse and Azure integration, Power Automate expressions, and Dataverse choice columns with formulas. These topics are useful signals for maintaining developer knowledge, but they should not be treated as a complete substitute for the current PL-400 skills outline.
How the current skills outline is weighted
Use the current skills outline as a time-allocation tool, not as a prediction of exact question counts. The study guide identifies the current skills-measured version as effective March 19, 2026, and Microsoft states that exams are updated periodically to reflect role requirements. Confirm the version that applies to your scheduled attempt before you commit to a final study plan.
The current blueprint assigns 10-15% to the Create a technical design domain, 10-15% to the Build Power Platform solutions domain, 5-10% to the Implement Power Apps improvements domain, 10-15% to the Extend the user experience domain, 40-45% to the Extend the platform domain, and 5-10% to the Develop integrations domain.
The Extend the platform domain has the largest stated range, so a plan that spends nearly all its time on canvas formulas or basic flow construction is poorly balanced. At the same time, a low-weight domain is not a zero-weight domain. Prepare every area, then give the greatest depth to platform extension while using the other domains to test whether you can select and combine components in a complete solution.
Create a technical design: 10-15%
The Create a technical design domain accounts for 10-15% of the questions you might encounter on the exam. Microsoft’s exam-readiness material frames this area around designing technical architecture and designing solution components.
Prepare by translating a business requirement into a component map. Identify the data source, user experience, business logic, automation, external systems, authentication boundary, security model, and deployment path. Then ask what should remain declarative and what genuinely requires code or another extension point.
A useful exercise is to write two designs for the same requirement: one using standard Power Platform capabilities and one requiring an extension. Compare maintainability, security, performance, ALM, and integration complexity. The purpose is not to memorize a preferred architecture; it is to make trade-offs explicit.
Build Power Platform solutions: 10-15%
The Build Power Platform solutions domain accounts for 10-15% of the questions you might encounter on the exam. Microsoft’s exam-readiness material highlights configuring and troubleshooting Power Platform and implementing application lifecycle management in this area.
Study the movement of a solution from development through test and deployment. Review solution components, dependencies, environment considerations, configuration, and the way a deployment choice affects troubleshooting. Practise finding why a component works in one environment but fails after import or configuration change.
Do not reduce ALM to clicking an export or import command. Build a small solution, change it in a controlled way, move it between environments if your access permits, and record the dependency or configuration issue when something breaks. That investigation produces stronger recall than copying a deployment checklist.
Implement Power Apps improvements: 5-10%
The Implement Power Apps improvements domain accounts for 5-10% of the questions you might encounter on the exam. Prepare to improve an existing app by selecting suitable Power Fx, data, usability, and performance changes rather than treating every problem as a reason to rebuild.
Work from an imperfect app. Examine delegation-sensitive formulas, data retrieval, error handling, validation, component reuse, and the separation of presentation from business logic. For model-driven apps, connect improvements to Dataverse behavior, forms, views, commands, and security rather than studying the app surface in isolation.
When practising, describe the symptom before choosing the fix. A slow screen, a missing record, an incorrect calculated result, and an unauthorized action can look similar to a user but require different investigations. This habit helps with scenario questions that ask for the most appropriate improvement.
Extend the user experience: 10-15%
The Extend the user experience domain accounts for 10-15% of the questions you might encounter on the exam. This is where you should connect custom interfaces and client-side behavior to the platform’s supported extension model.
Review when client scripting, custom components, custom pages, or other user-experience extensions are appropriate. Pay attention to event timing, data access, validation, user context, error handling, and the effect of customization on maintainability and ALM. JavaScript and TypeScript knowledge becomes useful when you must reason about behavior rather than recognize a product label.
Build one small user experience that includes a deliberate validation rule and a deliberate failure path. Document what executes in the client, what must be enforced on the server or in business logic, and how a user receives an actionable error. This distinction prevents a common mistake: assuming client validation alone protects data.
Extend the platform: 40-45%
The Extend the platform domain accounts for 40-45% of the questions you might encounter on the exam and deserves the deepest study block. Focus on the extension points that let a developer add business logic, custom experiences, automation, or service behavior when standard configuration is insufficient.
Build a comparison matrix for plug-ins, custom connectors, Power Apps component framework components, cloud flows, client scripts, web APIs, and Azure-backed integrations. For each, record where it runs, what event or trigger starts it, what data it can access, how it is secured, how it is deployed, and what failure behavior must be handled.
Include Power Platform CLI and developer workflow activities in your practice. The objective is not to memorize command syntax without context. It is to understand how source-controlled or repeatable development, packaging, testing, and deployment support a maintainable Power Platform solution.
Include AI tools, copilots, or agents only in the way the current objectives describe them: as tools or solution logic that can improve development, troubleshooting, or an implementation. Validate permissions, data exposure, predictable behavior, and fallback handling instead of assuming an AI feature is automatically suitable for production.
Develop integrations: 5-10%
The Develop integrations domain accounts for 5-10% of the questions you might encounter on the exam. Prepare for decisions involving Dataverse, RESTful Web APIs, custom connectors, Azure, authentication, data conversion, and the reliability of communication between systems.
Practise mapping fields and types between a Dataverse table and an external service. Consider authentication, pagination, throttling, retries, duplicate requests, error reporting, transformation, and ownership of the integration. A design that works for one successful request may still fail when a service is unavailable or a batch contains invalid data.
Use a simple integration lab to compare a standard connector with a custom connector or API-based approach. Record what each approach exposes to makers and developers, where credentials are held, and what the solution owner must configure in another environment.
What background to confirm before studying
Before buying training or scheduling, make an honest inventory of your development and Power Platform experience. PL-400 preparation is more efficient when you already understand the platform fundamentals and can spend the study period on design, extension, and troubleshooting rather than learning every basic concept for the first time.
Check whether you can create and relate Dataverse tables, build both canvas and model-driven apps, construct a cloud flow, and explain the data and security consequences of those choices. Then check your code foundation: can you read JavaScript or TypeScript, interpret JSON, work with RESTful APIs, and understand C# or Azure integration concepts at the level needed to diagnose a solution?
If your answer is no in several areas, use Microsoft’s Power Platform training collection first. The collection supports self-paced learning and instructor-led options. The PL-400T00-A course is an English course with a listed duration of 5 days, but a course schedule does not guarantee that the underlying skills have become practical. Build and troubleshoot alongside the instruction.
Do not infer readiness from having built one successful app. The exam role spans solution architecture, ALM, user experience, platform extension, and integrations. Your readiness evidence should therefore include at least one exercise that crosses those boundaries.
A practical readiness inventory
Create a table with the current blueprint domains as rows and three columns: “can explain,” “can build,” and “can troubleshoot.” Mark a skill as ready only when you can perform the action and explain an alternative or limitation. This exposes the difference between recognition from a tutorial and independent implementation.
For each weak row, write a specific question rather than a broad goal. Examples include: Which layer should enforce this rule? How does this component move through ALM? What happens when the external API fails? Which identity performs this operation? What is the least invasive supported extension? Use those questions to choose labs and Microsoft Learn modules.
When a course is the right choice
Choose instructor-led training when you need a fixed sequence, guided labs, or help connecting code development to Power Platform architecture. Choose self-paced learning when you already have a working environment and can turn each module into a build-and-break exercise.
Microsoft’s PL-400T00-A course is specifically associated with solution development using Power Platform services, JavaScript, JSON, TypeScript, C#, HTML, RESTful Web APIs, and Microsoft Azure. Its stated audience expects previous software development experience and foundational Power Platform hands-on experience, so beginners should close those prerequisites rather than rushing into the advanced course.
A study sequence that builds usable skill
Study in dependency order: establish the data and security foundation, design a solution, build it with standard components, extend the user experience, add platform logic and integrations, then test and troubleshoot the complete package. This sequence prevents isolated memorization and gives every later topic a concrete place in a working solution.
Use one evolving project throughout preparation. For example, model a business process in Dataverse, give users a canvas or model-driven interface, automate a state change, add a controlled extension, connect an external service, and move the solution through an ALM path. Keep the project small enough to rebuild after a design mistake.
The project is a learning device, not a prediction of exam content. The official practice assessment explains the style and difficulty of sample questions, but its questions are not the same as those on the exam and it does not represent the exam’s complete length or complexity.
Phase one: establish the platform model
Start by making the data model explicit. Define tables, columns, relationships, ownership, choices, and the records each persona may read or change. Build a small app and flow on top of that model, then intentionally alter a relationship or permission so you can observe the resulting behavior.
Review the boundaries between Power Apps, Power Automate, Dataverse, connectors, and external services. Ask which service owns each operation and where the authoritative business rule belongs. This prevents the common error of placing critical logic in a convenient but weakly protected interface formula.
Phase two: design before implementation
Take several business requirements and write a short technical design for each. Include components, data movement, identities, security, error handling, ALM, and a testing approach. Do not begin with a favorite feature; begin with the requirement and constraints.
Use the official technical-design Exam Readiness Zone episode as a review prompt for architecture and solution components. After watching, recreate the design exercise without notes and explain why each component exists. If you cannot justify a component, you are probably adding technology rather than solving the requirement.
Phase three: build standard capabilities first
Implement the first version with standard Power Apps and Power Automate capabilities. Use Power Fx and workflow expressions where they are appropriate, and test normal, empty, invalid, duplicate, and unauthorized cases. Keep a record of each limitation that prevents the standard design from meeting the requirement.
This phase teaches an important developer judgment: an extension is justified by a requirement or platform boundary, not by the fact that code feels more familiar. It also gives you a baseline for comparing a custom solution with a declarative one.
Phase four: add and test extension points
Now introduce one extension at a time. Depending on your environment and learning objective, that may include client scripting, a plug-in, a custom connector, a component framework control, an API call, or an Azure integration. For every extension, document its trigger, execution context, dependencies, security, deployment method, and failure path.
Test the extension outside the happy path. Try missing input, an invalid record, a permission mismatch, a slow or unavailable dependency, and a repeated request. Then decide whether the error should be handled by the client, server-side logic, flow, connector, or integration service.
Phase five: rehearse diagnosis and deployment
Break your own solution deliberately. Remove a dependency, change configuration, use the wrong connection, alter a schema, or send malformed data. Trace the symptom back to its layer, fix it, and record the diagnostic evidence that led you there.
Finish by moving the solution through a controlled ALM exercise. Review what is included, what is environment-specific, what must be configured, and what can fail after deployment. Troubleshooting after an import is particularly valuable because it joins design, security, dependencies, and operations.
A four-week roadmap for a working candidate
A four-week roadmap works when you already have the foundational experience described by Microsoft. Spend the first week on the blueprint and design, the second on Power Apps and ALM, the third on extension and integration work, and the fourth on diagnosis and assessment review. Adjust the calendar if your hands-on gaps are larger; do not compress unfamiliar coding into a last-minute review.
Set a measurable output for every week. A finished design, a working solution increment, a tested extension, and a written gap log are more useful than a target number of videos or pages.
Week one: blueprint, architecture, and data
Read the current PL-400 study guide and mark every objective as familiar, practiced, or unknown. Build the project’s Dataverse model, define personas and permissions, and produce a technical design. Review the Create a technical design episode, then revise the design after identifying dependencies and failure cases.
At the end of the week, you should be able to explain why the chosen app type, data model, automation, security boundary, and integration pattern fit the stated requirement. If you cannot, spend the next session on architecture rather than adding more features.
Week two: apps, automation, and ALM
Build the user experience and the first automation using standard capabilities. Exercise Power Fx formulas and Power Automate expressions in realistic conditions, including blanks, invalid values, and failed actions. Then review configuration and ALM by packaging or moving the solution where your environment supports it.
Use the Build Power Platform Solutions episode to reinforce configuration, troubleshooting, and ALM. Keep a deployment journal: component, dependency, environment-specific value, observed failure, and correction. This becomes a compact revision document grounded in your own work.
Week three: extension and integration
Spend the largest study block on Extend the platform because that domain accounts for 40-45% of the questions you might encounter on the exam. Compare extension points, build at least one custom behavior, and connect the project to an external service or API if your environment allows it.
Review authentication, security, data conversion, connector behavior, and Azure integration concepts. Include Power Platform CLI or the relevant developer workflow in your practice. The goal is to understand the lifecycle of an extension from design through deployment and troubleshooting, not to collect disconnected code samples.
Week four: troubleshoot, assess, and decide
Run a full review by domain. For each missed or uncertain topic, locate the underlying product documentation or Microsoft Learn module, perform a small verification exercise, and add the result to your notes. Avoid simply rereading the same explanation after an incorrect answer.
Take Microsoft’s PL-400 Practice Assessment as a diagnostic checkpoint. Microsoft describes Practice Assessments as free resources that can be attempted as many times as desired, and says they help identify knowledge gaps. Use the result to choose final study work; do not treat a practice score as a guarantee of the live result.
Finish with the exam sandbox so you recognize the interface and can interact with the available question types. The certification page warns that the assessment may include interactive components, so learning the interface is a sensible preparation step distinct from learning product content.
How to use Microsoft Learn without studying passively
Use Microsoft Learn as a loop of explanation, implementation, failure, and correction. Read the objective, build a small feature, vary the conditions, and explain the result in your own words. This is more reliable than completing modules while leaving every example unchanged.
The Power Platform training collection offers self-paced learning paths and instructor-led options. The PL-400 course syllabus is a useful spine for candidates who want structured coverage, while the study guide remains the authority for the skills measured on your exam version.
The Exam Readiness Zone includes a six-part sequence covering the high-level PL-400 areas. Use the technical-design and solution-building episodes to frame architecture and ALM, then continue through the related episodes listed by Microsoft for the remaining domains. Watch actively: pause before each recommendation and predict the design choice.
Build a small evidence portfolio
Keep four artifacts: an architecture diagram or component map, a data and security model, an ALM or deployment record, and a troubleshooting log. Add short notes explaining why an alternative was rejected. These artifacts make revision concrete and reveal gaps that a feature checklist hides.
Include code and formulas only where they demonstrate a decision. A long code listing is less valuable than a note explaining the trigger, execution context, permissions, error handling, and deployment implications of the code.
Turn mistakes into revision prompts
After every failed lab, write the failure as a scenario: “The flow succeeds for the maker but fails for another user,” or “The imported solution cannot resolve a dependency.” Then answer four questions: what layer failed, what evidence proves it, what fix is appropriate, and how would testing prevent recurrence?
Review these prompts in mixed order. Mixed practice forces you to identify the relevant domain and extension point instead of relying on the sequence in a course.
Common preparation mistakes to avoid
The most damaging preparation mistake is confusing familiarity with readiness. Watching a demonstration can make a feature appear obvious, while PL-400 scenarios require you to choose an implementation, account for constraints, and troubleshoot the result. Use hands-on verification and written reasoning to close that gap.
Avoid relying on dumps, leaked questions, or memorized answer patterns. They do not establish that you can build or diagnose a solution, and they can leave you unprepared when wording, scenarios, or product behavior differ. Microsoft’s practice assessment explicitly says its questions are examples and are not the same as the exam questions.
Do not study only the most visible Power Apps features. The blueprint gives the Extend the platform domain 40-45%, while the other domains test architecture, ALM, user experience, and integrations. A narrow canvas-app plan leaves major role responsibilities uncovered.
Do not treat preview behavior as permanent behavior. The study guide says most questions cover general availability features, although preview features may appear when they are commonly used. Check the current study guide and official product information rather than basing preparation on an old video or personal notes.
Do not postpone security and ALM. They affect nearly every implementation decision: who can execute logic, where connections are resolved, how components move between environments, and what happens when configuration differs. Add these questions to every lab.
Do not schedule immediately after a single strong practice attempt. First explain the answers you got right, investigate the ones you guessed, and confirm that your weakest blueprint domains have practical evidence behind them. A practice assessment is a readiness aid, not a replacement for training or product experience.
A better way to review an incorrect answer
Classify each error as a product knowledge gap, a design judgment error, a terminology confusion, or a reading mistake. Product gaps require documentation or a lab. Design errors require comparing alternatives. Terminology confusion requires a short glossary. Reading mistakes require slowing down and identifying the requirement, constraint, and requested outcome before selecting an answer.
Retake practice only after correcting the underlying issue. Repeating an assessment immediately can measure memory of the options rather than improved understanding.
Scheduling, language, and exam-day decisions
Microsoft states that PL-400 is proctored and that you will have 100 minutes to complete the assessment. The certification page also says interactive components may be part of the exam. Check the current exam details when scheduling because delivery policies, available languages, and accommodations are operational details that can change.
The listed exam languages are English, German, Spanish, French, Japanese, Portuguese (Brazil), and Chinese (Simplified). The study guide says other available languages are listed in the Schedule Exam section. If the exam is not available in your preferred language, Microsoft says you can request an additional 30 minutes to complete it.
Schedule through the official Microsoft certification page and Pearson VUE path, and use a personal Microsoft account as Microsoft strongly recommends. Confirm the account connected to your certification profile before booking so your result and credential are associated with the intended profile.
Microsoft reports that the English language version will be updated on March 19, 2026. The study guide provides two skills-measured versions depending on when you take the exam, and Microsoft updates English first; localized versions may follow on a different schedule. Match your study guide to your planned attempt rather than combining old and current objectives without checking the effective date.
Microsoft states that a score of 700 or greater is required to pass. Use that as the official scoring requirement, but do not convert it into a target percentage on an unofficial question set. The score scale and a practice assessment result are not interchangeable.
If you do not pass the first attempt, Microsoft states that you can retake the exam 24 hours after that attempt; subsequent retake timing varies. Review the official retake policy before making a rescheduling decision. If you need assistive technology, extra time, or another modification, request an accommodation through the official process before the appointment.
What to verify immediately before booking
Confirm the current skills-measured version, exam language, proctoring and delivery instructions, account association, accommodation needs, and the official rescheduling or retake rules. Also open the exam sandbox before the appointment and make sure your final revision notes cover every current domain.
Do not rely on a third-party page for a time-sensitive detail such as availability, language, scheduling, or policy. Use the Microsoft certification page and study guide linked in this article, because those are the sources supplied for these claims and are the places most likely to reflect a change.
How to manage the assessment time
The official duration is 100 minutes, so practise making a decision without turning every scenario into an open-ended architecture review. Read the requirement and constraints first, identify the affected layer, eliminate options that violate security or ALM needs, and then choose the supported approach that best fits the stated outcome.
If a question uses an interactive component, focus on the requested task and avoid changing unrelated settings. The sandbox can help you become familiar with the interface, but it cannot predict the exact content or complexity of the live assessment.
Using the official practice assessment correctly
Use the Microsoft Practice Assessment after an initial study pass, not as your entire preparation method. Microsoft says these assessments are free, can be attempted as many times as desired, and provide insight into question style, wording, and difficulty while helping identify knowledge gaps.
Treat every attempt as an audit. Record the domain, the reason for the answer, your confidence, and the evidence needed to verify it. A correct answer chosen by elimination is a review item; an incorrect answer caused by an unfamiliar feature is a lab item.
Microsoft also cautions that practice questions are not the same as live exam questions and do not illustrate the full length or complexity of the exam. Additional question types, case studies, and labs may occur. Use the assessment to improve judgment and coverage, then return to hands-on work.
Because Microsoft notes that Practice Assessments are updated in step with certifications, check the assessment page again when your exam version changes. Microsoft also notes that local-language Practice Assessments may become available later, so verify the current language options rather than assuming parity with the exam.
A simple readiness rule
Schedule when you can do three things consistently: explain the architecture behind a solution, implement or modify the relevant component, and troubleshoot a failure without copying a recipe. Your practice assessment should then confirm coverage rather than reveal an entire domain that you have never used.
If the result exposes a weak area, delay the appointment when practical and return to the blueprint. A short, targeted lab on ALM, platform extension, or integration is usually more valuable than another general review pass.
Your final preparation checklist
Before scheduling, identify the current exam version and map your experience to all six domains. Before the final study week, complete a small solution that includes Dataverse, an app, automation, security, and an ALM or integration decision. Before the appointment, verify official delivery details, language, account, accommodations, and retake rules.
Use this checklist as a decision record rather than a motivational list. If an item is uncertain, turn it into a Microsoft Learn lookup or a hands-on test.
Confirm that you can: design technical architecture and solution components; configure and troubleshoot Power Platform; apply ALM practices; improve canvas or model-driven app behavior; use Power Fx and workflow expressions in realistic cases; choose and test user-experience extensions; compare platform extension points; use developer tools such as Power Platform CLI in context; reason about authentication and security; transform data across system boundaries; handle integration failures; and explain how AI tools, copilots, or agents fit safely into solution development or troubleshooting.
Review the current blueprint’s domain labels with their weights: Create a technical design (10-15%), Build Power Platform solutions (10-15%), Implement Power Apps improvements (5-10%), Extend the user experience (10-15%), Extend the platform (40-45%), and Develop integrations (5-10%). Keeping each percentage attached to its domain prevents a misleading bare-number comparison.
Open the official exam sandbox and Practice Assessment. Investigate guesses as well as mistakes. Replace any unsupported memory with a source-backed explanation or a verified lab result.
After passing, note the 12-month renewal frequency and save the renewal page. Microsoft provides an online renewal assessment for eligible candidates and publishes a curated collection of renewal resources, so maintaining the credential is a separate planning task rather than an afterthought.
The next three actions
First, open the current PL-400 study guide and mark your weakest two domains. Second, create one small lab that crosses data, app, automation, security, and an extension or integration. Third, take the official Practice Assessment only after that baseline lab, then use its report to decide whether to schedule or study further.
That sequence gives you evidence for the decision that matters: whether you are ready to demonstrate developer judgment under assessment conditions, not merely whether you can recognize Power Platform terminology.
Conclusion
PL-400 preparation is strongest when it mirrors the role: design a solution, build it, extend it only where necessary, secure it, move it through ALM, integrate it responsibly, and troubleshoot what fails. Use the current Microsoft blueprint to allocate effort, the official learning resources to close knowledge gaps, and the practice assessment and sandbox to check readiness and interface familiarity. Verify time-sensitive scheduling details on Microsoft Learn immediately before booking, then make the appointment only when your hands-on evidence supports the decision.
Related exams
- AZ-140 exam — Configuring and Operating Windows Virtual Desktop on Microsoft Azure
- AZ-305 exam — Designing Microsoft Azure Infrastructure Solutions
- AZ-700 exam — Designing and Implementing Microsoft Azure Networking Solutions
- AZ-800 exam — Administering Windows Server Hybrid Core Infrastructure
- AZ-801 exam — Configuring Windows Server Hybrid Advanced Services
- DP-420 exam — Designing and Implementing Cloud-Native Applications Using Microsoft Azure Cosmos DB
Official sources
- Study guide for Exam PL-400: Microsoft Power Platform Developer
- Microsoft Certified: Power Platform Developer Associate
- Course PL-400T00-A: Microsoft Power Platform Developer - Training
- learn.microsoft.com
- learn.microsoft.com
- learn.microsoft.com
- Practice Assessments for Microsoft Certifications
- Renewal for Microsoft Certified: Power Platform Developer Associate
