Design Power Platform solutions with AI-enabled tools
Plans: from a business problem to a solution proposal
A maker types one sentence into plans in Power Apps, "Employees need to log vacation days, and managers need to approve them", and gets back the user roles, the Microsoft Dataverse tables, and the apps, flows and agents that a paid-time-off solution needs. Plans[1] is a copilot-first tool for exactly this first design step: you describe the business use case in natural language, optionally add images such as process diagrams or screenshots of a legacy app, and it proposes a complete Power Platform solution.
The Microsoft AB-410 study guide[2] lists the skill "Design Microsoft Power Platform solutions by using AI-enabled tools" under Create a foundation for intelligent applications (25–30%), with five bullets: "Analyze requirements to identify components and options for implementation", "Evaluate built-in agents to include in the business solution", "Recommend extensibility options", "Recommend environment types" and "Apply a Microsoft Power Platform solution and ALM strategy" (ALM is application lifecycle management, explained in Managed and unmanaged solutions below). It lists table design under a separate skill, "Build data models", with bullets such as "Create and modify columns", "Configure table relationships" and "Configure main forms"; see Build Dataverse data models.
Before you can start a plan
Plans requires[1] an environment (a Power Platform container for apps, flows and data, explained in Recommending an environment type below) that has a Dataverse database and an eligible locale. If the current environment does not qualify but you can use developer environments, plans routes you to your own developer environment, where you have permission to create Dataverse tables. Otherwise you must switch to an environment where you can create tables.
Three plan agents, in a fixed order
Plans works through three plan agents[3], AI assistants that each produce one stage of the proposal. Each stage waits for you to select Looks good before the next agent starts:
| Plan agent | What it produces | What you review |
|---|---|---|
| Requirements Agent | User roles, each with a description and user needs | Whether the roles and needs describe the real users and their work |
| Data Agent | Suggested tables with columns, data types and relationships | The data model, which Show details opens in the data workspace (the Power Apps visual designer for tables and relationships) |
| Solution Agent | A technology proposal: the apps, flows and agents that meet the needs | Each proposed technology's information card |
The order matters because each agent builds on the accepted output of the one before it. You can edit roles and needs inline, or ask Copilot to change them, before you accept them, so the data model and the technology proposal reflect the intended users. The table also tells you which agent owns which task: user needs come from the Requirements Agent, the schema from the Data Agent, and the technology mix from the Solution Agent. The Data Agent does not define user needs, and the Solution Agent does not design the schema.
The Solution Agent's proposal is traceable. Hovering over a proposed technology's information icon shows the user roles it meets and the data tables it uses[3], so judge a proposal by that mapping rather than by the component's name. The technologies plans can propose are canvas apps, model-driven apps, Power Pages websites, Power Automate flows, Power BI reports and Copilot Studio agents. One trap sits nearby: Copilot in the data workspace (the table-creation Copilot) focuses on tables and relationships, so it does not replace a plan when a requirement spans data, apps and automation.
From an accepted proposal to real objects
Accepting the proposal deploys nothing. To create objects such as apps, flows, sites and agents, you first select Save tables[3], which stores the plan in a solution (the package that moves work between environments, explained in Managed and unmanaged solutions below): you enter a solution name and choose a publisher (the owner of the components created in the solution, whose prefix is added to their names[4], explained in Solution publishers below), or select an existing solution. Only then do you create each object[5] in its own authoring experience. A canvas app opens in Power Apps Studio, a model-driven app in the app designer, a site in Power Pages design studio, a flow in the natural-language flow experience, and an agent in Copilot Studio, prefilled with a name, description, instructions and the plan's tables as knowledge. Each object still has to be saved and published before anyone can use it.
When an existing app already meets a need, select Replace on the proposed app's tile instead of building a duplicate, or select Add technology to attach another existing app. Existing apps you add to a plan aren't included in its new solution[5], so their solution membership stays separate.
A plan also has one editor at a time. Many authors can be present in a plan at the same time (copresence), but only one can edit[3]: the first author to open it gets editing rights, later arrivals stay read-only until that author leaves or becomes inactive, and multi-author coauthoring isn't supported.
As the figure below shows, the path from a business description to built objects runs through the three plan agents, each waiting for Looks good[3], and then through the steps you perform yourself: saving tables into a solution and creating each object. The takeaway: plans proposes and you decide at every stage; to create new proposed apps, flows or agents, save the plan into a solution and create each new object.
Matching requirements to Power Platform components
Plans proposes components, but a maker must still judge them. The rule: choose the component whose strength matches the requirement that dominates the scenario.
Canvas app or model-driven app
Microsoft compares the two app types[6] on several points:
| Decision point | Model-driven app | Canvas app |
|---|---|---|
| Data platform | Dataverse only | Dataverse plus many other sources through connectors |
| Layout control | Largely determined by the components you add (forms, views, charts, dashboards) | Full control of every screen |
| Responsive | Automatically | Only if designed that way |
| Navigation through relationships | Automatic, where relationships exist | Only where built with Power Fx formulas |
A model-driven app suits process-driven, data-dense work on Dataverse records, such as employee onboarding or a sales process; a canvas app suits a highly tailored interface or data from several sources. The device is not the deciding factor: model-driven apps have a similar interface across devices from desktop to mobile and are responsive automatically[6], so "users work on phones" alone does not call for a canvas app. The Microsoft AB-410 study guide[2] lists building each type as its own skill under Create intelligent applications (25–30%); see Create model-driven apps and Create canvas apps.
Power Pages for audiences outside the organization
When customers or partners need a website, choose Power Pages. It builds external-facing websites where users outside your organization sign in with a wide variety of identities, create and view data in Dataverse, or browse content anonymously[7]. Choose Power Pages for this external-facing website requirement.
An agent for conversation, an agent flow for the fixed sequence
Use a Copilot Studio agent when users should express requests in conversation, an app when they need screens and data controls, and an agent flow (a rule-based workflow in Copilot Studio; an existing Power Automate cloud flow can be converted into one[8]) when the work is a prescribed sequence of steps. These combine rather than compete: agent flows are deterministic, following a rule-based path in which the same input always produces the same output, and a flow with the When an agent calls the flow trigger can be added to an agent as a tool[8]. Adding a conversational front end therefore never requires replacing an agent flow's fixed sequence with generative decisions.
Dataflows for repeatable data loading
When data must be cleaned, transformed and loaded into Dataverse again and again, choose a dataflow[9]: you define the transformation steps once in Power Query and schedule automatic refreshes that rerun them, loading the prepared data into Dataverse tables. Contrast a virtual table, which reads rows from an external system at runtime and keeps no copy; it is the wrong choice when the requirement is to store regularly transformed copies in Dataverse.
As the figure below shows, three questions asked in order separate the interaction components: are the users external visitors on a website, do requests arrive in conversation, and does the app need tailored screens or data outside Dataverse. A model-driven app needs Dataverse: without a data model housed within Microsoft Dataverse, you can't create a model-driven app[6]. The takeaway: name the requirement that dominates (audience, interaction style, layout and data sources) and compare the components against it; consider a dataflow for repeatable Power Query preparation and loading.
Evaluating built-in AI assistance
Power Platform ships AI features you switch on instead of building, and evaluating one comes down to two questions: does a person stay in control of what it writes, and can it reach the data the question needs? (The plan agents in the first section are built-in AI too, but they help makers design a solution; the features here help app users do their work.)
Form fill assistance: suggestions a user accepts
Form fill assistance[10] gives model-driven app users optional AI suggestions for empty form fields, based on their recent use of the app, on text or an image they paste with smart paste, or on a file they supply. Suggestions carry citations, and they are not saved until the user explicitly accepts them; ignoring a suggestion counts as rejecting it. That makes the feature a fit for helping people enter data, and the wrong tool for enriching records when nobody is present to accept anything.
Control is per column. The column setting Allow form fill assistance (preview)[11] turns suggestions on or off for a supported column on main and quick create forms, so you can disable it for a column that holds sensitive information, such as an email address, and keep it elsewhere. The feature also needs at least one AI form fill assistance environment setting turned on. Do not confuse this with column-level security (column security profiles), which decides who may read or update a column's data and is not the switch for AI suggestions.
Copilot chat in model-driven apps: questions about Dataverse data
Copilot chat for model-driven apps[12] answers app users' natural-language questions about the Dataverse table data in the environment and can navigate the app for them. It retrieves data through read-only operations and cannot create or update records. Answering questions is a different job from form fill assistance, which proposes field values.
- Status. It is generally available in Dynamics 365 apps but remains a preview feature in Power Apps, and it will be deprecated for model-driven apps in environments not enabled for Dynamics 365 apps, starting January 2026[12]. Microsoft recommends switching those environments to Microsoft Copilot in model-driven apps[13] (the deprecation notice calls it simply Microsoft Copilot[12]; it is not the Microsoft Copilot Chat described below), a separate chat in the app that also answers questions about Dataverse table data and relies on Dataverse search indexes.
- Enablement. It isn't enabled by default for Power Apps environments[12]; a Power Platform administrator turns on its feature setting for each environment.
- Grounding. It draws on Dataverse search, the indexed search behind the model-driven global search bar: Copilot chat in model-driven apps is one of the generative AI experiences that use Dataverse search data[14]. Turning on Dataverse search supplies that data, but the chat itself still needs its own environment setting. In environments that use a customer-managed key or Customer Lockbox, answers won't be based on the Dataverse data[12].
Check what a Copilot experience can actually reach
Before you select a Copilot experience for questions about the business, check its grounding source (the data it draws answers from) and the asking user's permissions. Microsoft Copilot Chat is a different product from both model-driven app chats above: Copilot Chat (Basic) is the standalone chat included with eligible Microsoft 365 licenses, and it primarily uses web data[15]. It uses organizational content only when the user supplies it with the prompt (pasting, uploading or selecting a file), when it works with content open in an app such as Outlook or Teams, or through an agent that has access to organizational content. A web-grounded chat alone therefore cannot answer questions about internal records, which the model-driven app chats above answer from Dataverse data. And every Copilot experience scopes access by user permissions[15], so grounding in organizational data never reaches beyond what the signed-in user may access.
The takeaway: adopt a built-in AI feature when its human-control model fits the task and its grounding reaches the data the task needs, and confirm its preview or deprecation status before you design around it.
Choosing an extensibility option
Extensibility means adding custom code where the declarative options (low-code features you configure rather than code) stop; this page focuses on deciding whether code is needed and which kind to recommend, rather than on writing it. Microsoft's guidance[16] is to consider the declarative options first (business rules, calculated and rollup columns, Power Automate, and the other declarative options taught on Implement business and process logic) and to use code when a declarative process doesn't meet the requirement; the extensibility decision tree at the end of this page starts from that question, whether the declarative options are ruled out.
When code is justified, ask which layer the requirement lives in. Code components[17] enhance forms, views, dashboards and canvas app screens, client scripting[18] reacts to model-driven form events, a Dataverse plug-in[16] handles an event in a Dataverse data operation, and a custom connector[19] wraps a REST API, as the table below summarizes:
| The requirement needs | Recommend |
|---|---|
| A control the standard controls cannot provide | A code component |
| Different behavior of a model-driven form in the browser | JavaScript client scripting |
| Custom handling of a Dataverse data operation on the server | A Dataverse plug-in |
| An external API that has no prebuilt connector | A custom connector (the next section) |
Code components extend the interface
The Power Apps component framework[17] lets professional developers and app makers create code components for model-driven and canvas apps, used on forms, views, dashboards and canvas app screens. For example, a code component can replace a numeric column on a form with a dial or slider, or turn a list into a calendar or map bound to the dataset. Code components are reusable across tables and forms and are packaged in a solution. (A canvas component, built in Power Apps Studio without code, is a different thing; see Create canvas apps.) A code component changes how data is shown and edited, and it can also connect to external services through the browser.
Client scripting extends form behavior
JavaScript client scripting[18] attaches code to model-driven form events (the form loads, data changes in a column, the form is saved) and uses the client API to control what the form displays. Microsoft says not to make it the first choice: business rules apply form logic without code, and client scripting is for requirements that business rules cannot meet. It controls the client experience only, so it is the wrong answer both for a new visual control (a code component) and for logic that must run on the server whatever saves the row (a plug-in).
Plug-ins extend data operations on the server
A Dataverse plug-in[16] is a custom event handler: compiled .NET code registered on a specific event (a step) in the Dataverse event framework, the event pipeline that processes a Dataverse data operation. When the event occurs, the plug-in can cancel the operation and display an error, change the data being processed, run other data operations, or connect to external systems. The cost is a software developer to create and maintain it, and each run has a hard time limit.
The registration mode decides whether the user waits. A synchronous plug-in makes the data operation wait until its code finishes, while asynchronous execution is queued and runs after the data operation finishes[16]. Recommend synchronous only when the operation must depend on the result, such as blocking an invalid save; an asynchronous plug-in cannot prevent the original save, because the save has already finished when it runs. Plug-ins handle server-side data events, so they are the wrong tool both for rendering a control and for reacting to a form loading in the browser.
The takeaway: declarative options first, then match the extension to the missing layer: the interface, form behavior, a server-side data event, or an external API.
Connecting to APIs that lack a prebuilt connector
This section covers the fourth extension layer, reaching an external service. Power Apps, Power Automate, Copilot Studio and Azure Logic Apps share more than 1,000 prebuilt connectors[19], and a custom connector covers a service outside that list. A custom connector is a wrapper around a REST API[19] that exposes the API's operations as triggers and actions to those products. It is used the same way as a prebuilt connector: each user still needs a connection to the API, with authentication when the API requires it. A connection is a stored authentication credential for a connector[20] (explained in Connection references bind connections below), not the network path a gateway provides. A custom connector created in Power Apps is available in Power Automate and Copilot Studio, and one created in Power Automate is available in Power Apps and Copilot Studio. This page focuses on deciding whether a custom connector is the right fit, rather than on writing its OpenAPI definition.
A custom connector describes an API and can run custom code to transform requests and responses; it does not replace the API host or the connectivity the API requires. Two companion decisions follow:
- Where the API runs. For a public API you plan to create and manage, Microsoft suggests Azure products such as Azure Functions, Azure Web Apps or Azure API Apps[19]. Azure Functions then hosts the custom server-side processing, and the custom connector exposes it to Power Apps, Power Automate or Copilot Studio, which keeps the service's implementation apart from its low-code use.
- How traffic reaches it. An API that is visible only inside a private network is reached through an on-premises data gateway[19]. The connector defines the operations; the gateway supplies the connectivity.
The takeaway: a custom connector is the low-code view of an API that runs somewhere else, so pair it with a host for a new API and a gateway for a private one. Moving a custom connector between environments has its own ordering rule, covered in Connection references bind connections below.
Recommending an environment type
Every Power Platform solution lives in an environment, and choosing the type is a decision about lifecycle: how long the work must last and who may change it. An environment[21] is a space to store, manage and share an organization's business data, apps, agents and flows, and a container that separates apps with different roles, security requirements or audiences. Three properties shape every recommendation:
- One tenant. Each environment is created under a Microsoft Entra tenant, and only users in that tenant can access its resources.
- One location. An environment is bound to a geographic location: apps created in it are routed only to datacenters in that macro region, and its flows, connections and other items are bound to the same location. For production and sandbox environments, the location is set by the user at creation time[21].
- At most one database. Every environment can have zero or one Dataverse database[21], so development and production data that must stay isolated need separate environments, never a second database in one environment.
The environment types
The type indicates the purpose of the environment and determines its characteristics[21]:
| Type | Intended use | What rules it out |
|---|---|---|
| Production | Permanent work the organization depends on | Disposable, reset-based testing (use a sandbox) |
| Sandbox | Nonproduction development and testing, with copy and reset | Permanent business operation |
| Trial | Short-term testing; expires after 30 days, one per user | Anything that must keep running past the evaluation |
| Developer | Development by its owner only; security groups can't be assigned | Shared or centrally controlled access |
| Default | Experimentation, exploration and lightweight app trials | Production workloads (no backup guarantees) |
The default environment deserves its warning. Each tenant gets one default environment automatically, shared by all users in the tenant[21]: every new Power Apps user is added to its maker role, and all licensed users hold the environment maker role there, so it cannot isolate a restricted department's makers. It can't be deleted either. Use a production environment for business workloads.
The developer type is changing: unmanaged developer environments are deprecated[21], new ones can't be created starting November 15, 2026, and the developer type continues only as a managed developer environment, one per user. Managed here means Managed Environments[22], a suite of premium capabilities admins can use with any type of environment[23]: a property of the environment, unrelated to managed solutions (a solution type, explained in Managed and unmanaged solutions below). Dataverse for Teams environments are deprecated as well.
A healthy layout keeps development and testing apart from production, so experiments and validation never change the operational app or its data; the solution and pipeline sections below show how work moves between these environments. The takeaway: production for what the business depends on, sandbox for nonproduction work that may be copied or reset, trial for 30-day evaluations, developer for one person's own work, and never the default environment for production.
Managed and unmanaged solutions
Application lifecycle management (ALM), the way an app is developed from conception to end of life, runs on solutions in Power Platform. A solution is either managed or unmanaged[4], and the two have opposite jobs:
- Unmanaged solutions are developed. You work in an unmanaged solution in a development environment. It is your source: its exported unmanaged version belongs in source control, and it can be exported either as unmanaged or as managed.
- Managed solutions are deployed. Export the unmanaged solution as managed and treat the result as a build artifact for every environment that isn't its development environment, such as test, user acceptance testing and production. A managed solution can be serviced independently from other managed solutions.
Three rules follow from that split. First, you can't export a managed solution, so the unmanaged source is the only place to build the next version. Second, you can't import a managed solution into the same environment that contains the originating unmanaged solution[4], so testing the managed installation needs a separate environment. Third, you can't edit components directly within a managed solution: check the component's managed properties, which decide whether it can be customized, and if it can, add it to an unmanaged solution and customize it there. That customization creates a dependency on the managed solution, which then can't be uninstalled until the dependency is removed.
The same split explains a distribution mistake: shipping an unmanaged solution to customers delivers editable customizations, not a package that can be serviced on its own.
Deleting a solution: container versus contents
The two types behave oppositely on removal, so assess the effect before you delete. When an unmanaged solution is deleted, only its container is deleted[4]: its unmanaged customizations remain in effect, and any associated data also remains[24]. Those customizations can still be viewed from the Default Solution, because all objects can be viewed from the Default Solution[25] (it is compared with the Common Data Services Default Solution in Putting the right components into a solution below). Microsoft's solution concepts article[4] says the leftover customizations "belong to the default solution", and that sentence does not name either system solution. Deleting (uninstalling) a managed solution removes all the customizations it includes, and data stored in its custom tables, and in custom columns it added to other tables, is lost[4].
The takeaway: build unmanaged, ship managed, test the managed artifact in a separate environment, and treat a managed uninstall as an operation that can delete data.
Solution publishers
Every solution has a publisher, and the publisher decides two things you cannot easily change later: the names of your components and who owns them. Create your own publisher rather than use the default[4], and specify it when you create the solution.
- The prefix names your schema. The publisher prefix is added to the names of new metadata items to avoid naming collisions between publishers (Microsoft's example prefix is contoso). Change the prefix before you create any apps or metadata items, because the names of metadata items can't change after they're created[4]; a later prefix change does not rename existing tables or columns. The default Dataverse publisher's prefix is randomly assigned, for example
cr8a3[24]. - The publisher owns the component. The publisher of the solution in which a component is created owns that component. Ownership can move between solutions of the same publisher but not across publishers, and once a managed solution introduces a component, its publisher can't change. Microsoft therefore recommends defining a single publisher.
The takeaway: choose the publisher and its prefix before you create the first table, because existing metadata names cannot change and a component's publisher cannot change once introduced in a managed solution.
Solution dependencies
Managed solutions can build on each other: a modular product installs a base solution, then a second solution that customizes the base. The system tracks these dependencies[4]. Installing a solution whose base isn't installed fails with a message that another solution must be installed first, and the base can't be uninstalled while a solution that depends on it is still installed. So install the base first and the dependent second, and uninstall in the reverse order.
Before deleting a component, remove the dependencies on it[24], which you find through the component's dependency information. Managed properties are a different control: they decide whether a component can be customized and do not list what depends on it.
The takeaway: install the base solution before the solution that depends on it, uninstall in the reverse order, and remove the dependencies on a component before you delete it.
Putting the right components into a solution
Include the components the next environment needs and avoid unnecessary assets; this section covers how components get into a solution and out of it. Work inside a custom unmanaged solution: the Default Solution can't be exported for import to other environments[25].
The preferred solution
A preferred solution is the custom unmanaged solution that receives components created outside an explicit solution context. After you set it, objects you create go into that solution automatically[25]. When no custom preferred solution is set, the Common Data Services Default Solution is used by default, or the Default Solution if that fallback is unavailable. These two Dataverse system solutions have near-identical names but different roles: all objects can be viewed from the Default Solution, which can't be exported, while the Common Data Services Default Solution stores new objects by default, so other makers likely use it too[25]. The preference is not universal. Components created in the classic solution explorer don't go into it, and it currently doesn't work with several surfaces, including dataflows, AI Builder, connections, custom connectors and canvas apps created from an image or a Figma design, with only limited support for Power Automate flows. Check what actually landed in the solution rather than trusting the preference.
Segmenting tables
When you add a table to a solution, you choose how much of it to include. The options[24] are Include all objects (all the table's components and metadata), Include table metadata (table properties only) and Edit objects (pick individual columns, relationships, views, forms and other assets).
- The table already exists in the target, such as Account or a custom table imported earlier: segment it with Edit objects and include only the changed assets. This avoids unnecessary solution layers[24] (the per-component stack of solution definitions explained in Solution layers: what decides runtime behavior below) and unnecessary dependencies on other solutions.
- The table doesn't exist in the target yet: select Include all objects. Segmenting a table that has never been imported produces a missing dependency error at import[24].
Removing versus deleting
Two commands look alike and do very different things. Remove from this solution[24] takes an object out of the unmanaged solution while the object stays in the environment, available to other solutions. Delete from this environment deletes the object itself, can't be undone, and loses associated data such as the rows of a deleted custom table. To leave a component out of one release, remove it; do not delete it.
The takeaway: build in a custom solution, verify its membership even with a preferred solution set, segment tables that already exist downstream, include all objects for new tables, and remove rather than delete.
Servicing a managed solution: update, upgrade, patch
After the first release, each new version reaches test and production through one of three servicing operations, and the right one depends on whether anything must disappear. Microsoft's solution concepts[4] define them:
| Operation | What it does | Can it delete components? |
|---|---|---|
| Update | Adds or changes components of the parent managed solution | No |
| Upgrade | Replaces the solution with a new version, rolling up its patches and removing components the new version no longer contains; applied at once or staged | Yes |
| Patch | Carries only changes (added or edited components) for a parent managed solution, layered on top of it | No |
A release that retires a column must therefore be imported as an upgrade; an update or a patch leaves the omitted component in place. Patches and a staged upgrade stack as layers on top of the base[26], explained in Solution layers: what decides runtime behavior below, and using patches isn't recommended[26].
The takeaway: updates and patches only add or change, an upgrade is the only servicing operation that removes, and patches are best avoided.
Solution layers: what decides runtime behavior
When a deployed change seems to have no effect, inspect the solution layers. Layering is tracked per component[26], and the top layer is the current layer that defines the component's runtime behavior. Reading the stack from the bottom up:
- System layer: the tables and components the platform needs to function.
- Managed layers: every installed managed solution, each later installation above the one before it. Within one managed solution, the base layer sits at the bottom, patches stack above it, and a staged upgrade (the pending upgrade, named _Upgrade) sits above the base and any patches.
- Unmanaged layer: a single layer that all imported unmanaged solutions and ad-hoc customizations share.
Unmanaged customizations reside at the top layer for a component and so define its runtime behavior[27], which is rarely what you want in test or production: an unmanaged change made there can keep a newly imported managed definition from taking effect, so inspect that component's layers before redeploying. Deleting one unmanaged solution does not roll its changes back, because unmanaged solutions share one layer and have no separate layers to remove.
Layers rarely combine: only model-driven app, form and site map components are merged[26], and every other component, including canvas apps and cloud flows, uses top-wins (top-layer-wins) behavior, so two definitions of a cloud flow never combine their actions.
A staged upgrade is not inert: its pending layer sits above the base and any patches, so for top-wins components it can already set runtime behavior before you select Apply upgrade, which then flattens (consolidates) the layers into a new base.
The figure below draws the stack for one component with one managed solution installed. The takeaway: read the layers from the top, expect the top layer to win except for model-driven apps, forms and site maps, and remember that a staged upgrade already counts.
Diagnosing solution problems
Three tools answer three different questions about a solution, and choosing the wrong one leaves the real problem hidden:
| Tool | Question it answers | Works on |
|---|---|---|
| Solution checker | Does the solution follow best-practice rules? | An unmanaged solution that can be exported |
| Object checker | Is this object's live metadata or layering broken? | A model-driven app or site map, in a managed or unmanaged solution |
| Solution history | Did an import, export or uninstall succeed, and if not, why? | Operations on a solution |
Solution checker[28] runs a static analysis of a solution's components against a set of best-practice rules and reports problematic patterns, the affected components, and links to fixes. Its limit is stated plainly: using it doesn't guarantee that a solution import will be successful[28], because the static analysis doesn't know the destination environment's configured state or the other solutions an import may depend on. A clean report complements validating the import against the target; it never replaces that validation.
Object checker (preview)[29] runs real-time diagnostics on one object in an environment, such as a deployed model-driven app or site map, and detects issues like an active layer hiding customizations or malformed metadata, with a recommended fix. It currently works only with model-driven app and site map components. Reach for it when a deployed object misbehaves in test or production, where an offline check of the exported solution file cannot see the live layering.
Solution history[30], opened with See history in the Solutions area, lists each import, export and uninstall with its version, publisher, start and end time, and result. For a failed operation, the details show the Error code, the Exception message that helps diagnose the cause (dependency errors can link to the solution layers), and an Activity Id to give Microsoft Customer Support. History records older than 180 days are deleted automatically. A solution being present in an environment does not prove that its latest operation succeeded; the history does.
The takeaway: solution checker during development for code quality, object checker for a live object's layering, and solution history for why an operation failed.
Environment variables carry parameters
A solution moves between environments unchanged except for the few things that must differ, such as which SharePoint site a flow writes to and whose credentials it uses. Two solution components carry those differences, and keeping them apart is the skill: an environment variable holds a parameter, and a connection reference points to a connection, which holds a credential.
Environment variables[31] store parameter keys and values that apps, flows and other components use as inputs instead of hard-coding them. Because environment variables are solution components, the definition travels in the solution while the value can change per environment, for example a SharePoint Online site and list in development versus production. One variable can serve many components, so a change is made once. Hard-coding the production site into each component instead means editing the app and flows for every environment.
Each variable has a data type (Decimal number, Text, JSON, Two options, Data source or Secret) and up to two values:
- Default value: part of the definition, used only when there is no current value.
- Current value: the environment's own value, used whenever it exists, even if a default value is also present. Editing only the default value therefore changes nothing in an environment that has a current value.
To stop the development value from traveling, select Remove from this solution on the variable's Current Value before export. The value stays in development, and the destination supplies its own value at import; the import experience prompts for variables that have no value. Keep the definition in the solution for its consumers; remove only Current Value from the package.
For a secret, choose the Secret type, which references a secret held in Azure Key Vault; the vault must be set up so Power Platform can access the secret[31]. A Text variable is not a secret store.
The takeaway: the definition travels in the solution, each environment supplies its own current value, and secrets go in a Secret variable backed by Azure Key Vault.
Connection references bind connections
A connection is a stored authentication credential for a connector, and a connection reference is a solution component that contains a reference to a connection for a specific connector[20]. Solution-aware flows bind to connection references for all connectors, while solution-aware canvas apps use them only for implicitly shared non-OAuth connections (such as SQL Server Authentication, where the connection authentication the app author provides is implicitly shared with the app's users[32]); during import you provide a connection in the target environment for each reference, so the flows can be turned on automatically afterward. A data source environment variable does not replace a connection: it stores parameters such as sites and lists, while the connection represents the credential[31]. (The Microsoft AB-410 study guide[2] lists "Evaluate and recommend connectors" under "Create cloud flows"; see Create cloud flows.)
Keep these deployment considerations in mind for connection references:
- Existing flows are not converted automatically. A flow created outside a solution continues to use direct connections after it's added to a solution[20]. Convert it either by exporting and importing it in an unmanaged solution, or through the flow checker's Use connection references warning, whose action removes the connections so connection references can be selected.
- Turning a flow on needs every connection. The user who initially turns on a flow must own or have permission to use all of its connections; once the connection owner has activated it, any flow co-owner can turn it on. A
ConnectionAuthorizationFailederror means that user lacks permission to at least one connection: have the connection owners share all the connections, or have the owner of all the connections turn the flow on. The fix is permission on the connections, not a change of solution owner or publisher. - Custom connectors go first. Custom connectors need to be imported in a separate solution, before the connection references or flows that use them[20].
The takeaway: environment variables for what differs, connection references for which connection is used, and the destination supplies both at deployment.
Deploying with Power Platform pipelines
Power Platform pipelines bring automated ALM deployment into the product: an administrator sets up a pipeline in a pipelines host, the environment that holds the pipelines and stores the solutions exported for every deployment[33], and a maker deploys a solution from the development environment with a few selections. Keep these deployment considerations in mind:
- One artifact, every stage, in order. The solution is exported when the maker submits the deployment request, and that same artifact passes through the pipeline stages in sequential order[33]. The system doesn't re-export for later stages and prevents tampering with the artifact, so nothing can bypass QA. Changes made in development after the request are not in that artifact; they need a new deployment.
- Publish first. Pipelines don't publish unmanaged customizations before exporting the solution[33], so publish the objects that need it in development before you request the deployment.
- Prevalidation before deployment. Deployments are prevalidated against the target environment[33]: missing dependencies and other issues surface before deployment, and connections and environment variables are provided up front and validated, helping ensure the deployed app connects to the right data sources without manual repair afterward.
- Solutions and configuration, not data. Pipelines deploy solutions plus configuration for the target, such as connections, connection references and environment variables, but solutions don't contain data stored in Dataverse tables[33]. Records that must move need a separate migration.
- Managed artifacts into Managed Environments. Pipelines deploy managed solutions to the targets, importing as an upgrade without overwriting customizations. The pipelines host should be a production environment but doesn't have to be a managed environment, while every other environment in the pipeline except a developer environment must be enabled as a managed environment[33]. Enabling Managed Environments (see Recommending an environment type) on the host does not meet the production target's own requirement.
Tenant and geographic boundaries limit where a pipeline reaches. Pipelines can't deploy to a different tenant[33]; Microsoft recommends Azure DevOps or GitHub for that scenario. Deploying across regions within a tenant works only when the host's Cross-Geo Solution Deployments setting is enabled, and that setting is about geography, not tenants.
As the figure below shows, one deployment moves the same exported artifact through the pipeline stages in sequential order[33], from development to production. The takeaway: publish, request, let prevalidation catch dependency and configuration gaps, and expect the exact artifact that passed QA to reach production; move data and cross-tenant deployments by other means.
Power Platform design decisions by requirement
For each scenario, identify the requirement and constraints before comparing options that solve only part of it.
| Requirement or symptom | Recommended option | Option that falls short, and why (section) |
|---|---|---|
| A requirement spans data, apps and automation | Start a plan in Power Apps | Copilot in the data workspace alone: it generates tables and relationships (Plans) |
| The proposal looks right; what happens next? | Save tables into a solution, then create each object | Treating acceptance as deployment (Plans) |
| Field workers on phones, data in Dataverse, standard processes | A model-driven app | A canvas app chosen only for mobile use (Matching requirements) |
| Data must be reshaped and reloaded into Dataverse on a schedule | A dataflow | A virtual table: it reads external rows at runtime and stores no copy (Matching requirements) |
| Hide AI suggestions on one sensitive column | Turn off Allow form fill assistance on that column | A column security profile: it governs data access (Evaluating built-in AI) |
| Block a save unless a server-side check passes | A synchronous Dataverse plug-in | An asynchronous plug-in: it runs after the save (Choosing an extensibility option) |
| Call an API that is reachable only inside the company network | A custom connector plus an on-premises data gateway | The connector alone: it describes the API but opens no path (Connecting to APIs) |
| A test environment that is reset between test cycles | A sandbox environment | A trial, which expires, or production (Recommending an environment type) |
| Remove a retired column in production | Import the new version as an upgrade | An update or a patch, which cannot delete (Servicing) |
| Ship one new column on Account | Segment Account with Edit objects | Include all objects, which adds unrelated assets and layers (Putting the right components) |
| An imported managed change has no effect | Look for an unmanaged customization on top | Deleting an unmanaged solution to roll back (Solution layers) |
A flow won't turn on: ConnectionAuthorizationFailed | Share the connections, or turn it on as their owner | Changing the solution's owner or publisher (Connection references bind connections) |
| Development changes made after QA are missing in production | Submit a new deployment request | Expecting the pipeline to re-export (Deploying with pipelines) |
| Deploy to another Microsoft Entra tenant | Azure DevOps or GitHub | Enabling Cross-Geo Solution Deployments (Deploying with pipelines) |
Study advice: find the constraint that rules options out (audience, who acts, where the code runs, lifecycle, what must be deleted, what must travel), then compare the remaining options with the requirement.
Extensibility options: code component vs client scripting vs Dataverse plug-in vs custom connector
| Decision point | Code component | Client scripting | Dataverse plug-in | Custom connector |
|---|---|---|---|---|
| What it extends | The user interface: a control the standard controls cannot provide | Model-driven form behavior in the browser | Server-side processing of a Dataverse data operation | Access to an external API as actions and triggers |
| Runs when | The control renders on a form, view, dashboard or canvas screen | A form event fires: the form loads, a column changes, or the form is saved | A registered Dataverse event occurs, synchronously or asynchronously | An app, flow or agent calls one of its operations |
| Where it can be used | Model-driven and canvas apps | Model-driven app forms | Inside Dataverse, synchronously during or asynchronously after the data operation | Power Apps, Power Automate, Copilot Studio and Logic Apps |
| Typical requirement | Show a number as a dial or a list as a calendar | Change the form when a column changes, beyond what business rules can do | Validate or cancel a save, or change the data being saved | Call a REST API that has no prebuilt connector |
| Tempting wrong use | Choosing a UI control for connector actions when no custom UI is needed | Reacting to a data change on the server | Rendering an interactive control | Intercepting and cancelling a Dataverse operation |
Decision tree
Sharp facts the exam loves — give these one last read before exam day.
Cheat sheet
Sharp facts the exam loves — scan these before test day.
- Plans turns a business description into a proposed multi-component solution
When requirements span data, applications, and automation, use plans in Power Apps to develop a coordinated solution proposal. Supply the business use case in natural language and optionally add process diagrams, data models, or legacy-app screenshots to give Copilot context.
Trap Using the table-creation Copilot alone as the complete solution planner, although its output focuses on tables and relationships.
3 questions test this
- You're creating a plan in Power Apps to replace a legacy Access application. You have screenshots of the legacy screens and a diagram of the approval process, and you want Copilot to use both of them
- A maker described a new equipment inspection process by using Start with Copilot when creating tables, and Copilot generated tables and relationships. The team now needs Copilot to propose the apps an
- Contoso's facilities team describes a new process in a short paragraph. The solution must include Dataverse tables, an app for technicians, an approval flow, and possibly an agent, and the team wants
- Review user roles and needs before accepting the generated data model
Plans progresses from user requirements to the data model and then the technology proposal. Edit generated roles and needs inline or through Copilot before selecting Looks good, so later recommendations reflect the intended users and their work.
3 questions test this
- A plan in Power Apps generated employee and manager roles for a PTO solution. You need to add an HR admin role that monitors PTO across teams before the data model is generated, and you want Copilot t
- A plan in Power Apps has generated user roles and needs for a PTO solution. You reviewed them with the business owner, and they're correct and complete. You now want the Data Agent to suggest the tabl
- A plan in Power Apps generated user roles and needs for a facilities solution. Before the data model is generated, you must delete one generated need and add a Security Officer role, and you want to t
- Technology proposal details identify the requirements and tables each component serves
A proposed technology's information card identifies the user roles it supports and the data tables it uses. Review that mapping when deciding whether to accept the proposal or request changes, rather than evaluating the component name alone.
3 questions test this
- A plan in Power Apps proposes a model-driven app, a canvas app, and a cloud flow. Before accepting the proposal, a reviewer must confirm which user roles each proposed component supports and which dat
- Before accepting a plan's technology proposal, you hover over the information icon on each proposed technology. The info cards show that every user role is supported by at least one technology and tha
- A plan's technology proposal includes a canvas app named Field Visits. Its info card shows that the app supports only the Dispatcher role and uses only the Visit table, but technicians must also use i
- Save the plan and tables before creating the proposed solution objects
Save tables establishes the plan in a solution and asks for a solution and publisher, or an existing solution. After this step, create the proposed apps, flows, sites, or agents in their respective authoring experiences; a proposal is not already a published application.
Trap Treating acceptance of the technology proposal as deployment, although object creation and publication still remain.
3 questions test this
- A maker accepts a plan's technology proposal by selecting Looks good and tells business users that the new expense app is ready. Users can't find the app anywhere in Power Apps, and the plan hasn't be
- You're about to create the apps and flows that a plan in Power Apps proposes. Your team's ALM policy requires every object from the plan to be stored in an existing unmanaged solution named Ops, which
- You've accepted the technology proposal in a plan in Power Apps. You now want to create the proposed canvas app and cloud flow, and the plan and its tables must be stored in a new solution that uses y
- Plans can replace a proposed app with an existing app
When an existing app already meets the need, use Replace on the proposed app tile rather than create a duplicate. Add technology includes an additional existing app, but existing apps added to a plan are not automatically included in its new solution.
Trap Assuming an existing app attached to a plan is automatically packaged in the new solution, although its solution membership remains separate.
3 questions test this
- A plan proposes a canvas app and a cloud flow for an inventory solution. You also want to show an existing reporting app in the plan. That app isn't related to any of the proposed scenarios, and none
- You used Replace to swap a proposed canvas app for an existing app named App1 in a plan, and you saved the plan in a new solution named Sol1. You'll later deploy Sol1 to production and expect App1 to
- A plan for an HR onboarding solution proposes a new model-driven app for HR coordinators. Your team already has a published app named Onboard that meets every coordinator need, and maintaining two app
- Plans requires Dataverse and an eligible environment
Plans requires an environment with a Dataverse database and an eligible locale. If the current environment is unsuitable, eligible makers can be redirected to a developer environment; otherwise they must switch to an environment where they can create tables.
2 questions test this
- Your team will build business solutions with plans in Power Apps, and the plans will save new Dataverse tables. You're choosing which existing environment the makers should use so that the plans prere
- A maker opens Power Apps in an environment that has no Dataverse database and selects Create a plan. The maker is allowed to use developer environments in the tenant, and the plan must include several
- Plan copresence does not permit simultaneous editing
Plans can show multiple collaborators, but only one author can edit at a time. Later arrivals have read-only access until the editor leaves or becomes inactive, so shared edit permission does not imply concurrent coauthoring.
Trap Choosing copresence for simultaneous edits by several makers, although it provides only one active editing session.
3 questions test this
- Two makers who both have edit permission open the same plan in Power Apps a few minutes apart. The second maker sees the first maker's avatar in the command bar but can't change any part of the plan's
- You joined a plan in Power Apps while a colleague was editing it, so you have read-only access. You need to make several changes to the plan's user needs today, and you don't want to create a separate
- You'll run a workshop in which three makers, who are all Co-Owners of a plan in Power Apps, contribute changes to the plan's user requirements and data model. You want the session to run without anyon
- App-type selection depends on whether the experience or the data model leads the design
When a task needs a highly tailored interface and connections to multiple data sources, choose a canvas app. When the solution centers on Dataverse business data and related processes, choose a model-driven app whose forms and views generate a responsive interface from that model. The choice is about the dominant design requirement, not simply whether the app runs on a phone.
Trap Choosing a canvas app solely for mobile use, although model-driven interfaces also respond to device size.
3 questions test this
- Contoso's onboarding team needs an app over several related Dataverse tables, with standard forms, views, dashboards, and a business process flow. Users move between related records all day, and no on
- A team wants a simple app for logging equipment loans. The team's environment has no Dataverse database, and all of the data must stay in an existing SharePoint list. A maker proposes building a model
- Inspectors use phones and tablets in the field to work with inspection records stored in related Dataverse tables, guided by a business process flow. A colleague insists on a canvas app only because t
- Power Pages serves external website audiences using Dataverse
When customers or partners need an external-facing website connected to Dataverse, select Power Pages. It supports sign-in through a variety of identities and anonymous content browsing, allowing the solution to serve an external audience rather than requiring an internal application experience.
2 questions test this
- A museum wants a Dataverse-backed website where anyone can browse exhibition schedules without an account. Members must sign in with an external identity, such as a Google account, to see member-only
- Contoso's distributors don't work for Contoso and have no Microsoft Entra accounts in its tenant. They must sign in with their own Google or LinkedIn accounts to view and submit warranty claims that a
- An agent can provide conversation while a flow performs the repeatable process
When users need to express requests conversationally, use an agent as the interaction component; use an app interface when they need direct interaction with screens and data controls. A rule-based workflow remains appropriate for a prescribed sequence of actions. An agent can call an agent flow, so adding conversation does not require replacing the deterministic process with generative decisions.
Trap Replacing a fixed processing sequence with generative decision-making solely because requests arrive through chat.
4 questions test this
- An agent flow in Copilot Studio runs a fixed approval sequence for travel requests. Requests will now arrive through a chat agent, and a colleague proposes replacing the flow with the agent's own gene
- Claims processors must triage and update about 200 claim records each morning by using sortable grids, filters, and editable form fields. A colleague suggests a Copilot Studio agent as their only inte
- Facilities staff want to report building issues by chatting with an assistant in Microsoft Teams, which asks clarifying questions. Each issue must then follow a fixed sequence: create a work order, as
- Every night at 2:00 AM, a fixed sequence must copy approved timesheets into a payroll table and then email a summary to the finance team. No user interacts with the process at any point, and it must p
- Dataflows provide repeatable transformation and loading into Dataverse
When data must be cleaned, transformed, and loaded into Dataverse repeatedly, choose a Power Apps dataflow. Define the preparation steps in Power Query and configure automatic scheduled refresh to rerun them. This loads prepared data into the destination rather than merely previewing an imported file or reading external rows dynamically at runtime.
Trap Choosing a virtual table for a requirement to persist regularly transformed copies in Dataverse, although virtual tables expose external rows at runtime.
3 questions test this
- A maker's dataflow in Power Apps pulls student records from three CSV exports into Dataverse. On every scheduled run, full names must be split into first and last names, rows with a repeated student I
- You're creating a dataflow in Power Apps that prepares vendor data for a model-driven app. The loaded tables must be stored in Dataverse so that the app can use them, not in your organization's Azure
- Every night, Contoso's warehouse system updates a SQL Server database of stock levels. Before apps use the data, units must be converted and blank rows removed, and the prepared rows must be stored in
- The Requirements Agent translates the business problem into user needs
Use the Requirements Agent's output to establish who the solution serves and what each role needs to accomplish. It is the first planning stage; review its proposed roles and requirements before letting later agents design implementation components.
Trap Reaching for the Data Agent to define user needs, although its responsibility is the proposed data model.
5 questions test this
- You're using plans in Power Apps to design a solution for booking meeting rooms. Before any tables or apps are proposed, facilities managers must confirm which user roles the solution serves and what
- A plan in Power Apps for a visitor registration solution lists receptionists and hosts, but it omits security guards, who must sign visitors out at the end of each day. You need the later data model a
- In a new plan for a field service solution, stakeholders must first confirm what dispatchers and technicians need. After that, a data architect must adjust the proposed table relationships on a visual
- You select Generate after describing a business scenario in a new plan in Power Apps. Your manager wants to schedule reviewers for the plan's first output before any implementation design begins, and
- A plan in Power Apps has generated user roles and needs for a PTO solution, and the data model hasn't been generated yet. A stakeholder wants employees to also be able to view PTO blackout dates, and
- The Data Agent proposes tables, columns, and relationships
The Data Agent translates the accepted business needs into a proposed data model with tables, column types, and relationships. Its suggestions can be reviewed and edited in the data workspace before the plan proceeds to technology selection.
Trap Using the Solution Agent as the schema-design specialist, although its role is choosing the technologies that consume the data.
5 questions test this
- The Data Agent in your plan has suggested five tables for a training management solution. A data architect needs to see the tables as a diagram and edit their relationships directly, without describin
- In a new plan in Power Apps for a field inspection solution, you review the generated user roles and needs and select Looks good. A reviewer asks what the plan produces next, so the right person can c
- You are reviewing a plan in Power Apps for a vehicle booking solution. A stakeholder asks for the relationship between bookings and vehicles to be changed, and for a missing column to be added, before
- A data architect is reviewing a plan in Power Apps for a training solution. Before the plan proposes any apps, the architect wants to check the recommended tables, the data types of their columns, and
- In a new plan for a field service solution, stakeholders must first confirm what dispatchers and technicians need. After that, a data architect must adjust the proposed table relationships on a visual
- The Solution Agent recommends technologies for the accepted requirements and data
The Solution Agent evaluates the needs, processes, and data to propose apps, flows, and agents. Use it when deciding the combination of implementation components, then review whether each proposed component addresses the business problem.
Trap Using the Requirements Agent to select the final app and flow combination, although it establishes needs rather than the technology proposal.
5 questions test this
- Your plan's requirements say that managers need a report of spending trends that they can filter and drill into, and no one should have to design app screens for it. You want the plan's technology pro
- Your plan's requirements include a dial control that replaces a numeric column on a model-driven form. You're checking whether the Solution Agent's technology proposal can supply that control or wheth
- A plan in Power Apps proposes a canvas app, a model-driven app, and a Power Automate flow for a supplier onboarding solution. Reviewers decide that external suppliers need a Power Pages website instea
- Your plan in Power Apps already has accepted user requirements and an accepted data model for an expense solution. You now need a recommendation for which combination of apps, flows, and agents should
- A plan for a purchase request solution includes a requirement that each new request is routed automatically to the requester's manager for approval, with no one starting the process by hand. You're re
- Form fill assistance offers suggestions that require explicit acceptance
When users need help entering data while retaining control, evaluate built-in form fill assistance. It suggests values for empty fields from recent usage, smart-pasted text or images, or supplied files; suggestions are not saved unless the user explicitly accepts them.
Trap Choosing form fill assistance for unattended record enrichment, although its suggestions depend on user review and acceptance.
3 questions test this
- A logistics company receives several thousand shipment records from a partner integration into a Dataverse table overnight. Before dispatchers start work, an empty Handling notes column on each record
- A user opens a record in a model-driven app where form fill assistance shows suggested values in several empty fields. The user accepts none of the suggestions and tries to move to another record. You
- Users of a model-driven app receive partner details in plain-text emails. They want to copy an email's text and have AI propose values for the matching empty fields on the main form, reviewing each su
- Form fill assistance can be disabled for individual sensitive columns
The Allow form fill assistance column setting (preview) controls whether a supported column receives AI suggestions. Disable it for sensitive columns while retaining assistance elsewhere; using the feature also requires an enabled AI form fill assistance environment setting.
Trap Using a column security profile solely to suppress AI suggestions, although it governs data access rather than the assistance setting.
3 questions test this
- You're adding a new Applicant table to a Power Apps model-driven app. Users must get automatic AI suggestions for its text and date columns, but a column named Tax ID must never receive suggestions. T
- Your model-driven app uses form fill assistance. A column named Bank Account on the Supplier table holds sensitive data and must never receive AI-generated suggestions. Users must still see and edit t
- Your compliance team decides that no Power Apps model-driven app in an environment may show automatic AI field suggestions that are based on users' recent data entry, on any column, until a review is
- Copilot chat provides conversational data insights where that experience remains supported
Copilot chat for model-driven apps lets users ask natural-language questions about Dataverse data rather than receive form-entry suggestions. This experience depends on Dataverse search, and enabling search alone does not enable every Copilot feature. Evaluate its availability before selecting it: Microsoft documents this as a preview feature in Power Apps, with deprecation beginning January 2026 for environments not enabled for Dynamics 365 apps, and recommends Microsoft Copilot as the replacement there.
Trap Selecting form fill assistance for conversational questions about existing records, although its purpose is proposing field values.
4 questions test this
- Service managers use a model-driven app in an environment that's enabled for Dynamics 365 apps. They want to type questions such as how many high-priority cases were created last week and get answers
- In October 2026, you're designing a new model-driven app for an environment that isn't enabled for Dynamics 365 apps. Users must be able to ask natural-language questions about the app's data, and the
- Users of a model-driven app in an environment that's enabled for Dynamics 365 apps use Copilot chat. When they enter a slash (/) to pick a specific account record for a question, the record picker doe
- Copilot chat is turned on for every model-driven app in an environment that's enabled for Dynamics 365 apps. An app named HR Cases must not show the Copilot pane to its users, while the other apps in
- Copilot selection must account for the business context it can actually access
For questions about organizational information, evaluate the proposed Copilot experience's grounding sources and the user's permissions. Web-grounded chat alone does not establish access to internal business context; that context must be available through a supported organizational-data capability, agent, or explicitly supplied content. Organizational grounding remains scoped by user permissions.
Trap Selecting web-grounded assistance for internal-record questions without providing a supported source of organizational context.
3 questions test this
- Two employees ask an agent the same question about internal project documents, and the agent is grounded in organizational content. One employee receives details from a restricted document, but the ot
- Support staff use Microsoft Copilot Chat, which is grounded in web data only. They need answers that draw on hundreds of internal troubleshooting articles in SharePoint every day, without uploading or
- Employees use Microsoft Copilot Chat, which is grounded in web data only. An employee wants a summary of an internal pricing guideline document that's stored in OneDrive, and the answer must reflect t
- Custom connectors expose services that lack a suitable prebuilt connector
When the solution must call an API that has no suitable prebuilt connector, recommend a custom connector. It wraps API operations as reusable actions or triggers for Power Platform consumers; a connection is still needed to use the API, with authentication when required by the API.
Trap Selecting a Power Apps component framework control for connector actions when no custom user interface is needed.
3 questions test this
- You created a custom connector for an internal ordering API that is published on the internet and requires OAuth 2.0 authentication. A maker adds one of the connector's actions to a cloud flow and wan
- Your integration team built a custom connector in Azure Logic Apps for a partner's REST API by using an OpenAPI definition. Makers now need the same API operations in Power Automate cloud flows and ca
- A logistics partner's REST API can notify subscribers whenever a shipment's status changes. You need a cloud flow to start automatically when that notification occurs, without polling on a schedule. N
- Power Apps component framework extends the application's visual controls
Recommend a Power Apps component framework code component when standard controls cannot provide the required data interaction or visualization. Components can replace a numeric field with a dial or present a dataset as a calendar, and can be reused in supported canvas and model-driven experiences.
Trap Choosing a Dataverse plug-in to render a custom interactive control, although plug-ins execute server-side data-event logic.
3 questions test this
- A model-driven app shows a Pressure column on its main form as a plain numeric value. Field technicians need to view and change the value by using an interactive dial on the form, and no standard cont
- Your team needs one custom slider control that makers can reuse on screens in several canvas apps and on main forms in model-driven apps. No standard control provides the required interaction, and the
- A model-driven form has a subgrid of service locations. Dispatchers want the subgrid's records shown on an interactive map in the same form context. A colleague proposes a Dataverse plug-in that draws
- Dataverse plug-ins extend data operations when declarative options are insufficient
Recommend a Dataverse plug-in when a requirement needs custom handling of a Dataverse data event and available declarative options do not meet it. A plug-in can augment or cancel the data operation, but requires developer implementation and maintenance.
Trap Choosing a custom connector to intercept and cancel Dataverse operations, although a connector exposes callable API operations rather than an event-pipeline handler.
3 questions test this
- Users delete Contract rows from model-driven apps, canvas apps, and integrations that call the Dataverse Web API. A delete must be stopped with an error message whenever the contract still has unpaid
- When a user saves a Contract row, Dataverse must evaluate pricing rules that are stored in several related tables and stop the save with an error message if the rules fail. Business rules and other de
- Order rows are created by a model-driven app, a canvas app, a cloud flow, and integrations that call the Dataverse Web API. A discount must be calculated and written to each row during the same save f
- Synchronous extensions delay the data operation while asynchronous extensions run afterward
A synchronous Dataverse plug-in makes the data operation wait for its work, so recommend it only when the operation must depend on the result. Asynchronous execution queues the extension after the operation finishes and is appropriate when the work can occur later.
Trap Selecting an asynchronous plug-in to prevent the original save, although that operation has already finished before the queued work executes.
3 questions test this
- A developer registered an asynchronous plug-in that validates new Order rows and is meant to stop invalid orders from being saved. Rows are created from apps and Web API integrations. Testers report t
- A Dataverse plug-in checks a customer's credit limit when an order row is created. If the check fails, the order must not be saved, and the user must see the error immediately in the app that submitte
- After an order row is saved, a Dataverse plug-in sends the order to an ERP system, which can take several seconds. Users must not wait for the ERP call to finish, and saving the order must not depend
- Private API integration can require an on-premises data gateway
For an API visible only within a private network, evaluate an on-premises data gateway alongside the custom connector. The connector describes the operations, while the gateway supplies the connectivity path to the private service.
Trap Treating a custom connector definition as a network tunnel, although describing an API does not provide private-network connectivity.
3 questions test this
- Contoso's inventory API runs on a server in the corporate datacenter and isn't reachable from the internet. Makers need to call it from several cloud flows through a custom connector that's already de
- A vendor's API is published on the internet over HTTPS and uses API key authentication. You're creating a custom connector so that cloud flows can call it. A colleague insists that you also install an
- A hospital's bed-tracking service exposes a REST API on a server inside the hospital network, with no public endpoint. An architect's diagram shows cloud flows calling the service through a custom con
- Azure Functions can host custom APIs exposed through a connector
When a solution needs custom server-side processing outside Dataverse, Azure Functions is an option for hosting the API. A custom connector can expose that API to Power Apps, Power Automate, or Copilot Studio, separating service implementation from low-code consumption.
Trap Treating the custom connector as the API's execution host, although it wraps a service implemented elsewhere.
3 questions test this
- Developers deployed an HTTP-triggered Azure function that calculates shipping rates. Makers in an environment without a Dataverse database must call it from canvas apps and cloud flows as one reusable
- Developers built an HTTP-triggered Azure function that scores loan applications with custom C# logic. Makers call it from canvas apps, cloud flows, and Copilot Studio agents through a custom connector
- Your team must run custom C# processing that calls several external services and isn't tied to any Dataverse data event. Makers must be able to call the processing from Power Apps, Power Automate, and
- Client scripting extends model-driven form interactions beyond available low-code capabilities
When a model-driven form interaction cannot be achieved with supported low-code form capabilities, recommend JavaScript client scripting through the supported client APIs. Scripts can respond to form events such as loading or column changes to control the client experience. This is a client-behavior extension, rather than a request for a replacement visual control or server-side handling of a Dataverse data operation.
Trap Choosing a Dataverse plug-in to react directly to a form-load interaction, although plug-ins handle server-side data events.
2 questions test this
- On a model-driven app's main form, a column named Resolution must become required whenever the Status column is set to Closed. Makers on the team who don't know JavaScript must be able to maintain and
- On a model-driven app's main form, when a user saves a Case row, client logic must call the client API to check related values and show a form notification in the browser before the user leaves the fo
- Production environments are intended for permanent operational workloads
Use a production environment for business workloads on which the organization depends. Keep development and testing separate so experiments and validation do not modify the operational application and data.
Trap Selecting the default environment as the standard production location, although it is intended for exploration and lightweight experimentation.
2 questions test this
- A critical expense app has run for a year in your tenant's default environment. Auditors note that the environment has no backup guarantees and that every licensed user is a maker there. You need a su
- Contoso is ready to release a model-driven app that the finance department will use every day to process supplier invoices. The app and its Dataverse data must reside in an environment that the organi
- Sandbox environments provide copy and reset capabilities for nonproduction work
Choose a sandbox when development or testing needs an isolated environment that can be copied or reset. Its purpose is nonproduction validation rather than permanent business operation.
Trap Choosing a production environment for disposable reset-based testing, although sandbox is the type designed for those operations.
3 questions test this
- Your team needs a nonproduction environment for testing changes to a production app before release. Before each test cycle the team copies production into it, and after each project the environment mu
- Contoso created an environment named QA as a production environment, but the team uses QA only for testing new releases. The team now needs to be able to reset QA to factory settings between projects
- A sandbox environment named Lab2 hosted a pilot project that has ended. You need Lab2 returned to factory settings for a new project, without any of the pilot's apps, flows, connections, or data, and
- Trial environments expire and suit short-term evaluation
A standard trial environment expires after 30 days and is intended for short-term testing. Choose a permanent environment type when the solution must continue operating beyond the evaluation period.
Trap Using a trial environment for a permanent departmental service, although the environment has an expiration lifecycle.
2 questions test this
- A maker created a standard trial environment 25 days ago to evaluate Dataverse features and built two test apps there. Nobody has converted or changed the environment since then, and the maker plans t
- Three weeks ago, a regional office created a standard trial environment and built a visitor sign-in app in it. The app is now essential, so it must keep running permanently in this environment, and th
Each tenant automatically receives one default environment, and licensed users receive Environment Maker access there. Its exploration-oriented purpose and lack of backup guarantees make it unsuitable for production workloads; it cannot be deleted.
Trap Choosing the default environment to isolate a restricted department's makers, although its maker population is tenant-wide.
4 questions test this
- The finance team builds and runs several apps in the tenant's default environment. A Power Platform administrator tries to assign the Finance makers security group to the default environment, so that
- A user who was just assigned a Power Apps license can immediately create apps and flows in the tenant's default environment, although no administrator granted the user any role there. The security tea
- Your manager proposes hosting a new business-critical app in the tenant's default environment, because it already exists and can't be deleted. You must explain why a different environment is preferabl
- Your organization moved every business-critical app out of the tenant's default environment into dedicated production environments. A Power Platform administrator now proposes deleting the default env
- Developer environments are for individual development rather than shared production
Developer environments are intended for the owner's development work, and security groups cannot be assigned to them. Recommend a production or sandbox environment when the requirement is a centrally controlled operational or shared testing environment.
Trap Selecting a developer environment for security-group-controlled production access, although that environment type does not support assigning security groups.
4 questions test this
- A maker finished an app in the maker's own developer environment, and 40 sales users must now start using it every day. The users' access must be managed centrally, and the app must run where business
- A team of five testers needs a shared environment for validating releases before production. Access must be controlled by assigning the team's Microsoft Entra security group, and the environment must
- A maker wants a personal environment for learning Power Apps and building prototypes with Dataverse tables over the next year. No one else will use it, nothing will be shared or promoted, and it must
- A team of five makers plans to build and test a shared solution in a developer environment. Corporate policy requires that access to every shared environment be controlled by assigning a Microsoft Ent
- An environment contains at most one Dataverse database
A Power Platform environment can have zero or one Dataverse database. When a solution needs independently isolated Dataverse databases for development and production, place them in separate environments rather than attempting to add a second database to one environment.
Trap Adding a second Dataverse database inside the existing environment for production isolation, although the environment supports only one.
3 questions test this
- A solution must have four independently isolated Dataverse databases: one each for development, testing, user acceptance testing, and production. An administrator wants to use as few Power Platform en
- Contoso has an environment named Env1 whose Dataverse database supports a production app. Developers need their own isolated Dataverse database for building the next release, and their work must not a
- An environment named Env2 was created months ago without a Dataverse database, and its makers already built connections and cloud flows there. A maker must now build a model-driven app with new Datave
- An environment's location determines the geographic placement of its resources
When a solution requires a particular geographic placement, select an environment in the appropriate location because the environment and the resources created in it are bound to that geography. Apps created there are routed to datacenters in that macro region. For production and sandbox environments, the location is selected at creation time.
3 questions test this
- Contoso's tenant home location is the United States. A new HR solution must keep its apps, flows, and Dataverse data in Europe to meet a data residency requirement. You're now creating the production
- A production environment named EnvUS is located in the United States geography. A maker in Germany creates a new canvas app, two cloud flows, and their connections in EnvUS, and the compliance team as
- A department wants to build its apps in the tenant's default environment, which is located in the tenant home location in North America. Regulations require the department's apps and data to be hosted
- Develop unmanaged solutions and distribute managed build artifacts
Use an unmanaged solution as the editable source in development, and export it as managed for downstream test and production environments. Keep the unmanaged source in source control; an installed managed solution cannot itself be exported as the development source.
Trap Distributing an unmanaged solution as the third-party product artifact, although it becomes editable customizations rather than a separately serviceable managed package.
3 questions test this
- Your company is an ISV that sells a Dataverse solution to many customers. Customers must receive a package that can be serviced independently of their own customizations, and they must not edit its co
- The only copy of a business solution is a managed solution that's installed in production. The original development environment was deleted. A developer wants to export that installed solution so that
- Your team develops a solution in an unmanaged solution in a development environment and deploys managed builds to test and production. You need to choose what to check in to source control as the sour
- Deleting a solution has different effects for managed and unmanaged packages
Deleting an unmanaged solution removes its container but leaves its customizations in the default solution. Uninstalling a managed solution removes its included customizations and can delete data in its custom tables and custom columns, so assess those effects before removal.
Trap Using managed-solution uninstall as a harmless container cleanup, although it removes included assets and their stored data.
3 questions test this
- A test environment contains a managed solution named Field Audit that includes a custom table and a model-driven app. Other teams' managed solutions in the same environment must stay installed. You ne
- A managed solution named Field Service Add-on is installed in production. It contains a custom Inspection table with thousands of rows and a custom column on the Account table. A maker plans to uninst
- Your development environment contains an unmanaged solution named Pilot. Pilot holds a custom table, a canvas app, and a cloud flow that other makers still use in their own work. You need to remove Pi
- Choose the custom publisher prefix before creating schema components
The solution publisher's prefix identifies new metadata components and reduces naming collisions. Create or select the appropriate custom publisher before creating tables and columns, because changing the publisher prefix later does not rename existing schema items.
Trap Changing the publisher prefix after creating a column to rename its schema, although existing metadata names are immutable.
2 questions test this
- Developers created several columns with the prefix cr8a3_ in an unmanaged solution. A lead then changes the solution publisher's prefix to fab and expects the existing columns to show the new prefix i
- Contoso is starting a new Dataverse project. All new tables and columns must use the prefix contoso, and they must not use the randomly assigned prefix of the default publisher. No tables have been cr
- Managed component ownership cannot be moved between publishers
A component's creating solution publisher owns that component. Ownership can move between solutions of the same publisher, but not across publishers after introduction in a managed solution, so choose publisher boundaries before distributing the product.
Trap Moving an existing managed component to a newly named publisher to transfer ownership, although ownership transfer is limited to solutions within the same publisher.
3 questions test this
- Fabrikam's managed solution includes a table that was created under the publisher fabrikam. After a rebrand, Fabrikam creates a new publisher named northwind and wants the table's ownership transferre
- Contoso plans several modular managed solutions that will customize one another's components. Contoso wants to keep the option of moving a component from one of its solutions to another later as the l
- Contoso's publisher, named contoso, owns two managed solutions named Core and Sales. A table that was created in Core should be shipped and owned by Sales in future releases, and the table must keep i
- Solution dependencies determine installation and removal order
Install a required base solution before installing a dependent solution. Removal reverses that order: dependent solutions or customizations must be removed before the base can be uninstalled. Use dependency information to identify what requires a component before deleting it.
Trap Inspecting managed properties to find every dependent component, although those properties control customizability rather than dependency relationships.
3 questions test this
- A vendor ships two managed solutions: Base, which defines core tables, and Analytics, which customizes components in Base. A test environment has neither installed, and an administrator plans to impor
- You plan to delete a custom column named Region from an unmanaged solution in development. Before you delete it, you need to identify every view, form, and flow that uses the column so that you can re
- A test environment has two managed solutions: Base and Extensions, which depends on components in Base. You must remove both solutions from the environment, and the administrator starts by trying to u
- Managed properties determine which distributed components remain customizable
Before extending a managed component, inspect its managed properties. If customization is permitted, add it to an unmanaged solution and customize there; the change creates an unmanaged dependency on the installed managed solution.
Trap Editing the component directly inside the managed solution, although permitted customizations must be made through an unmanaged solution.
3 questions test this
- Your unmanaged solution adds custom columns to a table that belongs to a vendor's managed solution named VendorCore. Months later, an administrator tries to uninstall VendorCore from the environment a
- The managed properties of a vendor's managed table allow new columns to be added. You need to add a Region column to that table in your development environment so that the change can be deployed with
- A vendor's managed solution includes a Service Plan table. Your team wants to add a column to that table for internal tracking in your own solution, but you aren't sure whether the vendor allows that
- Test a managed export in an environment separate from its unmanaged source
A managed solution cannot be imported into the environment that contains its originating unmanaged solution. Use a separate test environment to validate the managed installation and dependency behavior before production deployment.
Trap Importing the managed export back into the source environment to test installation, although the originating unmanaged solution prevents that import.
3 questions test this
- A maker exported an unmanaged solution named Sales as managed from the development environment. To test the managed installation quickly, the maker tries to import the managed file back into that same
- Contoso builds an unmanaged solution named Inventory in a development environment. Before each release reaches production, the team must validate the managed build's installation and dependency behavi
- Diego exports an unmanaged solution named Billing as managed from an environment named DevEnv. He imports Billing_managed.zip back into DevEnv to check the managed installation, and the import fails.
- A preferred unmanaged solution captures supported work outside explicit solution context
Set a custom unmanaged solution as the preferred solution when supported components created outside an explicit solution context should enter your deployment package automatically. The preference is not universal: components created in classic solution explorer do not enter it, and other authoring surfaces have documented limitations. Verify package membership rather than treating the preference as a guarantee for every component.
Trap Relying on the preferred solution to capture classic solution explorer creations, although that surface does not honor the preference.
3 questions test this
- Your preferred solution is an unmanaged solution named Sol1. During a sprint, you create a dataflow that loads product data, a new form on an existing table, a new view, and a new column, all outside
- You set an unmanaged solution named Sol1 as your preferred solution. A colleague then creates a new table by using the classic solution explorer and expects the table to appear in Sol1 automatically,
- Makers in a development environment often create apps and tables outside of any solution, and those components end up in the Common Data Services Default Solution. You want supported components to lan
- The system Default Solution is not an exportable deployment package
The system solution named Default Solution cannot be exported for import into another environment. Put the components to distribute in a custom solution instead of relying on their visibility in the system-wide Default Solution.
3 questions test this
- A maker adds a canvas app to an unmanaged solution named Sales and starts exporting Sales for a test environment. The app uses a custom table that the maker created outside any solution, so the table
- A maker built two apps and a table without using a custom solution. The components are visible in the system solution named Default Solution, and the maker wants to export them from there so that they
- A development environment contains three solutions: the system solution named Default Solution, which shows every component; an unmanaged solution named Sales, which contains an app and its tables; an
- Segment existing tables to ship only the assets that changed
When a table already exists in the target environment, use table segmentation to include the changed table assets and required dependencies rather than all unrelated components. Use Edit objects to select the needed columns, forms, or views. This reduces unnecessary solution layers and dependencies.
Trap Selecting Include all objects for a single-column change on an existing target table, introducing unrelated assets and layers.
3 questions test this
- You added a new column named Top Ten to the Account table in development. Production already contains the Account table and all of its other components. You need the solution update to include only th
- Your team adds the Account table to each release solution by selecting Include all objects, although each release changes only one or two Account columns. Production also has a vendor's managed soluti
- The Contact table already exists in production. In development, you changed only the table's auditing and change tracking settings, and none of its columns, forms, or views changed. You need a segment
- A table absent from the target requires Include all objects
When a table does not yet exist in the target environment, select Include all objects when adding it to the solution. Segmenting that new table can omit parts of its definition and produce missing-dependency errors during import.
Trap Applying existing-table segmentation to a first-time table deployment, leaving the target without required components.
3 questions test this
- A maker created a custom table named Asset in development and added it to a solution by selecting Include table metadata, following the team's segmentation guidance for release updates. Asset has neve
- Your next release adds a new column to the Contact table, which already exists in production, and introduces a new custom table named Equipment, which has never been imported into production. The rele
- You created a custom table named Inspection in development. The table has never been imported into the test environment. You're adding Inspection to a solution that you'll export and import into test
- Removing a component from a solution preserves it in the environment
Use Remove from this solution when an object should leave an unmanaged package but remain available in the environment. Delete from this environment is the destructive alternative: it removes the object and can remove associated data, such as rows stored in a deleted custom table.
Trap Choosing Delete from this environment to exclude a component from one release package, removing the underlying object instead of only its membership.
2 questions test this
- An unmanaged solution named Rel2 contains a custom table that the next release shouldn't ship. Other solutions in the development environment still use the table, and the table and all of its rows mus
- A maker selects a custom table named Survey in an unmanaged solution and chooses Delete from this environment, intending only to keep it out of the next export of the solution. The table held thousand
- Use a solution upgrade when obsolete components must be removed
A managed solution update adds or modifies components but does not delete omitted components. An upgrade removes components no longer included and can roll patches into a new base, so use an upgrade when the release retires an asset.
Trap Importing an update to remove an omitted column, although updates leave components that are absent from the new package.
3 questions test this
- Version 2.0 of a managed solution adds new forms and no longer includes a Legacy Code column from version 1.0. Production users must keep the Legacy Code column and its data for now, and no second cop
- A managed solution in production has a base version and three patches that were imported over several months. You're importing a new major version, and you want the base solution and all of its patche
- Version 2.0 of a managed solution no longer includes an obsolete Legacy Code column that version 1.0 added to production. When you import version 2.0 into production, the column must be removed, and t
- A solution patch contains changes to a parent and cannot delete components
A patch packages additions or modifications for a parent managed solution and is layered above that parent. It cannot remove components; Microsoft currently recommends avoiding patch-based servicing in favor of a simpler solution lifecycle where possible.
Trap Selecting a patch to uninstall one obsolete component, although patches only add or modify parent-solution assets.
3 questions test this
- You import a patch for a managed solution named Field, and the patch modifies one form. You then open See solution layers for that form to explain to a reviewer how the patch relates to the parent sol
- The next release of a managed solution named Field must retire an obsolete view in production. Field is currently serviced with patches, and a developer proposes shipping the retirement as one more sm
- Your team plans its release process for a managed solution and wants to keep team development and source control simple. A developer suggests using clone a patch and clone solution in development for
Imported unmanaged solutions and ad-hoc customizations share a single unmanaged layer rather than separate independently removable layers. Inspect that active layer when a managed deployment appears not to change runtime behavior, because unmanaged customizations can remain above managed definitions.
Trap Deleting one unmanaged solution container to roll back its layer, although unmanaged solutions do not have separate runtime layers.
3 questions test this
- In a test environment, a form's behavior comes from an unmanaged solution named Hotfix that was imported over a managed solution. You need the form to use the managed definition again, and you accept
- You imported two unmanaged solutions, SolA and SolB, into a test environment, and both customized the same form. You now want to roll back only SolA's changes to the form, so you delete the SolA solut
- You import version 3.0 of a managed solution that changes the label of an Account column. In production, users still see the old label. An administrator had earlier customized the same column directly
- Forms, model-driven apps, and site maps merge across solution layers
Model-driven apps, forms, and site maps support merge behavior when layered customizations are combined. Other component types generally use top-layer-wins behavior, so do not expect a canvas app or cloud flow to merge like a form.
Trap Expecting two cloud-flow definitions to merge their actions, although cloud flows use top-layer-wins behavior.
3 questions test this
- You import a managed solution that customizes the main form of a table that already exists in the environment. After the import, the form shows an autogenerated tab named Conflicts Tab that contains s
- Two managed solutions from the same vendor are installed in a production environment. Base adds a Sales area to a model-driven app's site map, and Ext, which is installed later, adds a Service area to
- You're importing a new version of a managed solution that includes a table's main form. You select the Overwrite Customizations option because you expect the imported form to replace the existing cust
- A staged upgrade can affect runtime before Apply upgrade consolidates the layers
A staged upgrade appears as a pending upgrade layer above the base and patches. For top-layer-wins components, that pending layer can already determine runtime properties; Apply upgrade subsequently consolidates the layers into the new base.
Trap Treating a staged upgrade as entirely inert until Apply upgrade, although its top layer can already determine component behavior.
3 questions test this
- You imported a new version of a managed solution by using Stage for Upgrade and completed a data migration. The environment now shows the base solution and a second solution with the suffix _Upgrade.
- Version 2.0 of a managed solution replaces a Region choice column with a Region lookup column. You need both the old and new versions installed at the same time in production so that you can migrate t
- The Comments column on the Account table has a Max length of 100 in a managed solution's base layer. You import version 2.0 by using Stage for Upgrade, and the pending upgrade sets Max length to 150.
- Solution checker analyzes static quality rather than guaranteeing target import success
Run solution checker on an exportable unmanaged solution to identify problematic patterns against best-practice rules. Its static analysis does not know the destination environment's configuration or installed dependencies. A clean report therefore complements, rather than replaces, target import validation.
Trap Substituting solution checker's clean report for target dependency validation, although static analysis does not inspect target configuration.
3 questions test this
- Solution checker reported no issues for an unmanaged solution named Sol1. When you import the managed export of Sol1 into production, the import fails because of a missing component that another solut
- A partner gave you a managed solution that contains JavaScript web resources. Before installing it, you want to run solution checker in your environment to find problematic patterns in its components.
- Before each release, your team wants a quick report that lists problematic patterns in its solution's JavaScript web resources, Power Automate flows, and Power Fx expressions, with links to documentat
- Object checker diagnoses live metadata and layering problems
When a deployed model-driven app or site map has an ALM-related problem in test or production, use object checker (preview) to analyze its live database metadata and layering. It examines the object regardless of which solutions contain it, unlike solution checker's offline analysis of a single exported solution file.
Trap Using only an exported package's solution checker results to diagnose the deployed object's live layering state.
3 questions test this
- Your team wants to use object checker (preview) on several components in a production solution: a model-driven app's site map, a cloud flow, a canvas app, and a custom table. Object checker is enabled
- After a release, users in production report that recent changes to a model-driven app's site map don't appear. You suspect that an active layer is hiding the customizations, and you want real-time dia
- In production, a model-driven app named Field Ops is installed only through a managed solution. Users report that recent changes to the app don't appear, and you suspect a layering problem. A colleagu
- Solution history records operation outcomes and failure diagnostics
Use See history in the Solutions area to inspect import, export, and uninstall operations and their results. For a failed operation, open its details and examine the Error code and Exception message; the Activity Id helps correlate the failure with support investigations. A solution's presence in the environment does not establish that its latest operation succeeded.
3 questions test this
- A solution upgrade failed in production. You opened the operation in the solution history and reviewed the error code and the exception message, but you still need Microsoft Customer Support to invest
- An import of a managed solution into a test environment failed overnight during a scheduled deployment. You need to view the error code and the exception message from that operation in Power Apps so t
- An attempt to uninstall a managed solution named Vendor failed in a test environment because of a dependency. You open the failed operation from See history and want the part of its details that can i
- Environment variables separate deployable logic from environment-specific parameters
Use environment variables for configuration such as a SharePoint site or list that differs between development and production. Transport the definition in the solution and supply the destination value during deployment, allowing multiple consuming components to reuse one parameter.
Trap Hard-coding the production site in each component before export, although that requires changing the application for each environment.
3 questions test this
- A production solution contains a canvas app and four cloud flows that all read an environment variable that stores a SharePoint site URL. The site is being retired, and every component must switch to
- You are adding a SharePoint list as a data source to a solution-aware canvas app. The list's site and name will differ in each environment, and you want Power Apps to resolve the site and list from a
- You are building a solution that contains a canvas app and two cloud flows. All three components read and write the same SharePoint list, but the SharePoint site and list differ between the developmen
- An environment variable's current value takes precedence over its default value
A defined current value is used even when a default value exists. The default is the fallback when no current value exists, so changing only the default will not replace an explicit destination value.
Trap Editing the default to override an existing production current value, although current-value precedence keeps the explicit value in use.
3 questions test this
- An environment variable named ApiUrl has a default value in its definition. In the test environment, nobody has set a current value for ApiUrl during import or afterward. A cloud flow in the test envi
- A solution in development includes an environment variable named ApiBaseUrl. Its definition has a default value that points to the test API, and a maker also set a current value that points to the dev
- You're importing an updated solution into production. The solution includes an environment variable definition with a default value, but you removed the variable's current value from the solution befo
- Remove source values from the solution when destinations need their own values
Before export, use Remove from this solution on the environment variable's current value when it should not travel to the next environment. The development value remains in the source environment, while deployment can supply a different destination value.
Trap Deleting the variable definition to avoid exporting the source value, although consuming components need the definition to resolve the parameter.
3 questions test this
- Your development solution contains an environment variable whose current value points to a development SharePoint site. When you deploy to test, the test team must provide its own value during import,
- You export a solution after removing the current values of its environment variables from the solution. Two of the variables have no default value. A colleague imports the solution into a test environ
- A managed solution that you imported into production included an environment variable's current value by mistake. Your team needs the value record itself to be deleted from production, and the variabl
- Secret environment variables use Azure Key Vault configuration
Use a Secret environment variable for a secret that components must reference through Azure Key Vault. Configure the required vault access rather than treating an ordinary Text variable as a dedicated secret store.
Trap Using a Text environment variable as the secret-management mechanism, although it does not provide the Secret type's Key Vault integration.
3 questions test this
- A Secret environment variable references an Azure Key Vault secret, and cloud flows in the solution already read it successfully. Now a Copilot Studio agent must use the same secret, and the vault use
- A cloud flow in a solution calls a partner API by using an API key. Security policy states that the key must be stored in Azure Key Vault, referenced by the solution rather than embedded in it, and ch
- You configured Azure Key Vault for Power Platform and registered the Microsoft.PowerPlatform resource provider. When a maker saves a new Secret environment variable, the error "User isn't authorized t
- Connection references bind solution components to destination connections
A connection reference is a solution component that points to a connector connection, while the connection contains authentication information. Bind references to usable target connections during import; use environment variables separately for parameters such as SharePoint sites and lists.
Trap Using a data-source environment variable to carry authentication, although it stores parameters rather than the connection's credentials.
3 questions test this
- A managed solution contains four cloud flows that use connection references for SharePoint and Office 365 Outlook. A data source environment variable stores the SharePoint site for each environment. Y
- A solution contains several cloud flows that use the Office 365 Outlook and SharePoint connectors. When the solution is imported into test and production, each flow must automatically use connections
- A canvas app and a cloud flow in a solution connect to SQL Server by using basic SQL authentication. The server and database names differ between the test and production environments, and the componen
- Adding an existing flow to a solution does not immediately replace its direct connections
A flow created outside a solution initially retains direct connections after it is added to a solution. Use the flow checker's Use connection references migration action, or export and import the unmanaged solution, to replace those connections with solution-aware references.
Trap Assuming Add existing automatically converts all flow connections, although connection-reference migration is a separate step.
3 questions test this
- A maker built a cloud flow outside any solution months ago and today used Add existing to add it to an unmanaged solution. When the maker opens the flow's details page in the solution, the flow checke
- A maker created a cloud flow named Flow1 outside of any solution and then used Add existing to add it to a solution. You need Flow1 to use connection references instead of direct connections. You don'
- You added ten existing cloud flows, which were all created outside solutions, to an unmanaged solution. You're about to move the solution to a new development environment by exporting it as unmanaged
- Activating a deployed flow requires access to every referenced connection
The user initially turning on a flow must own or have permission to use all its connections. A ConnectionAuthorizationFailed error therefore calls for checking connection permissions or activation by the connection owner, not merely changing the solution publisher.
Trap Assigning solution ownership to fix connection authorization, although ownership of solution metadata does not grant use of each underlying connection.
3 questions test this
- A service principal will turn on solution flows in production. The flows use connections that a developer owns, and the developer won't be available to activate them. You need the service principal to
- An integration engineer who owns every connection in a solution flow turned the flow on after import. Later, a co-owner of the flow who doesn't own those connections needs to turn the flow off for mai
- You imported a managed solution into production. A release manager tries to turn on a cloud flow in the solution and receives a ConnectionAuthorizationFailed error. The flow's connections were created
- Import custom connectors before the references and flows that depend on them
Custom connectors need to be imported in a separate solution before their connection references or dependent flows. Plan this dependency sequence rather than expecting one combined import to establish the connector and all its consumers reliably.
Trap Packaging the custom connector and its connection references into a single first import, although the connector must already be available for the dependent import.
3 questions test this
- Fabrikam's production environment has the following configuration: A solution named FreightConnector, which holds only the Freight API custom connector, was imported two weeks ago. Production cloud fl
- In production, an administrator created a custom connector named Shipping API directly on the Custom connectors page, outside any solution, with the same definition as the development connector. You m
- You must deploy a solution that contains a custom connector, two connection references that use the connector, and three cloud flows that call it. The target environment doesn't contain the custom con
- Pipelines promote the same exported artifact through sequential stages
A pipeline exports the solution when deployment is requested and promotes that same artifact through the later stages. It does not re-export development changes for each stage, ensuring that the artifact reaching production is the one that passed earlier validation.
Trap Editing development after QA and expecting the new changes in the same production promotion, although the pipeline retains the original export.
3 questions test this
- A pipeline has Test and Production stages. A maker has an urgent fix in development and wants to select the Production stage first, so that the fix reaches users immediately and is tested later. The p
- A maker deployed version 1.0.0.4 of a solution to the Test stage of a pipeline. After testing finished, the maker changed a form in development without incrementing the solution version and then deplo
- Version 1.0.0.6 of a solution passed the QA stage of a pipeline and is waiting for the Production stage. A maker then fixes a typo on a form in development, and the team wants the fix in production. T
- Pipelines deploy solutions and configuration rather than Dataverse business records
Pipelines deploy solution components and target configuration such as environment variables and connection references. They do not carry the business data stored in Dataverse tables, so plan a separate data-migration mechanism when records must move too.
Trap Relying on pipeline deployment to copy customer rows with their table schema, although business records are not included in the solution artifact.
3 questions test this
- A solution deployed with a pipeline contains a Product Category table, a model-driven app with its site map, two connection references, an environment variable, and 400 category rows that the app need
- A solution contains a custom Product Category table. Development has 400 category rows that production also needs. A maker plans to deploy the solution with a pipeline and assumes that the rows will b
- A maker's solution includes a new global choice with 12 options and three new views of the Order table. Before the first pipeline deployment to production, the maker worries that these items will have
- Production pipeline targets must satisfy Managed Environments requirements
A production destination used by Power Platform pipelines must be enabled as a Managed Environment. The pipeline host is recommended to be production but does not itself have to be managed; distinguish the host's orchestration role from the destination requirement.
Trap Enabling Managed Environments only on the host to satisfy production-target requirements, although the destination has its own requirement.
2 questions test this
- You're setting up Power Platform pipelines. The setup has a pipelines host, a sandbox environment named Dev for development, a QA target, and a production target. You must enable Managed Environments
- In October 2026, an admin receives a notice on the admin deployment page that a pipeline deploys to an unmanaged target environment named Test. The automatic managed environment setting isn't turned o
- Native Power Platform pipelines do not deploy across tenants
When deployment must cross Microsoft Entra tenants, use an ALM approach such as Azure DevOps or GitHub rather than native Power Platform pipelines. Cross-region support within a tenant does not imply cross-tenant deployment support.
Trap Enabling Cross-Geo Solution Deployments to support another tenant, although that setting addresses geography rather than tenant boundaries.
4 questions test this
- Your team uses native Power Platform pipelines for most releases and is reviewing four planned deployments. You must identify which deployment needs a different ALM tool, such as Azure DevOps or GitHu
- Contoso's pipelines host and development environment are in its own Microsoft Entra tenant. The production environment for a new customer project belongs to the customer's separate Entra tenant, in an
- Contoso develops a solution in its own Microsoft Entra tenant and must deploy it to a production environment that belongs to a subsidiary's separate Microsoft Entra tenant. The team wants an automated
- Your makers deploy to test and production in your own Microsoft Entra tenant by using native Power Platform pipelines, and they want to keep that experience. A new requirement adds an automated deploy
- Publish customizations before requesting pipeline deployment
Pipelines do not automatically publish unmanaged customizations before exporting. Publish the components that require publication in development before requesting deployment so that the exported artifact includes the intended published changes.
Trap Using the pipeline request as the publication step, although the pipeline does not publish those unmanaged customizations.
3 questions test this
- A maker changed several columns on a main form in an unmanaged solution and saved the form but didn't publish it. The maker then deployed the solution to test with a pipeline. In the test environment,
- A team lead documents the release process for makers who use Power Platform pipelines. The lead must state which part of the process publishes the unmanaged customizations, such as edited forms and vi
- In development, a maker edits Form A and publishes it, and then edits View B and saves it without publishing. The maker then deploys the solution to the Test stage with a pipeline. Which of these chan
- Pipeline prevalidation checks dependencies and target configuration before deployment
Pipelines prevalidate the solution against the target and collect connection and environment-variable configuration before deployment. Resolve missing dependencies and invalid configuration at that stage instead of planning to repair every environment manually after import.
3 questions test this
- A maker selects a pipeline stage, chooses Deploy now, and selects Next. The solution depends on a component that doesn't exist in the target environment. The maker wants to know when this problem will
- A maker selects Deploy here for the Test stage of a pipeline and then selects Next. Validation reports that the solution depends on a component that doesn't exist in the Test environment, and the make
- A solution that you deploy with a pipeline contains two connection references and three environment variables. The team wants the deployed flows connected to the correct target data sources without an
References
- https://learn.microsoft.com/en-us/power-apps/maker/plan-designer/plan-designer
- https://learn.microsoft.com/en-us/credentials/certifications/resources/study-guides/ab-410
- https://learn.microsoft.com/en-us/power-apps/maker/plan-designer/create-plan
- https://learn.microsoft.com/en-us/power-platform/alm/solution-concepts-alm
- https://learn.microsoft.com/en-us/power-apps/maker/plan-designer/build-solution
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/model-driven-app-overview
- https://learn.microsoft.com/en-us/power-pages/
- https://learn.microsoft.com/en-us/microsoft-copilot-studio/flows-overview
- https://learn.microsoft.com/en-us/power-apps/maker/data-platform/create-and-use-dataflows
- https://learn.microsoft.com/en-us/power-apps/maker/common/faq-from-filling-assistance
- https://learn.microsoft.com/en-us/power-apps/maker/data-platform/create-edit-field-portal
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/add-ai-copilot
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/add-microsoft-365-copilot
- https://learn.microsoft.com/en-us/power-platform/admin/configure-relevance-search-organization
- https://learn.microsoft.com/en-us/microsoft-365/copilot/microsoft-365-copilot-overview
- https://learn.microsoft.com/en-us/power-apps/developer/data-platform/plug-ins
- https://learn.microsoft.com/en-us/power-apps/developer/component-framework/overview
- https://learn.microsoft.com/en-us/power-apps/developer/model-driven-apps/client-scripting
- https://learn.microsoft.com/en-us/connectors/custom-connectors/
- https://learn.microsoft.com/en-us/power-apps/maker/data-platform/create-connection-reference
- https://learn.microsoft.com/en-us/power-platform/admin/environments-overview
- https://learn.microsoft.com/en-us/power-platform/important-changes-coming
- https://learn.microsoft.com/en-us/power-platform/admin/managed-environment-overview
- https://learn.microsoft.com/en-us/power-apps/maker/data-platform/create-solution
- https://learn.microsoft.com/en-us/power-apps/maker/data-platform/preferred-solution
- https://learn.microsoft.com/en-us/power-platform/alm/solution-layers-alm
- https://learn.microsoft.com/en-us/power-apps/maker/data-platform/solution-layers
- https://learn.microsoft.com/en-us/power-apps/maker/data-platform/use-powerapps-checker
- https://learn.microsoft.com/en-us/power-apps/maker/data-platform/object-checker
- https://learn.microsoft.com/en-us/power-apps/maker/data-platform/solution-history
- https://learn.microsoft.com/en-us/power-apps/maker/data-platform/environmentvariables
- https://learn.microsoft.com/en-us/power-apps/maker/canvas-apps/connections-list
- https://learn.microsoft.com/en-us/power-platform/alm/pipelines