Domain 1 of 3 · Chapter 1 of 2

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.

Describe the business problemRequirements Agent:user roles and needsLooks goodData Agent: tables,columns, relationshipsLooks goodSolution Agent: apps,flows and agentsLooks goodSave tables into asolution and publisherCreate each object inits designer, publish
The plans workflow in Power Apps: three plan agents propose roles, tables and technologies, then you save into a solution and build each 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.

External visitors ona website?YesPower PagesNoRequests arrive inconversation?YesCopilot StudioagentNoTailored screens ordata outside Dataverse?YesCanvas appNoModel-driven appon Dataverse data
Choosing the interaction component for a requirement: Power Pages, a Copilot Studio agent, a canvas app or a model-driven app

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.

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:

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 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).

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.

Read from the top: the toplayer sets runtime behaviorUnmanaged layer (shared)One managed solutionPending upgradePatchesBase layerSystem layer
Dataverse solution layers for one component: the unmanaged layer over one managed solution's pending upgrade, patches and base, over the system layer

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 ConnectionAuthorizationFailed error 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:

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.

Publish customizationsin developmentMaker requestsdeploymentPipeline exports thesolution oncePrevalidation: dependencies,connections, variablesManaged artifactdeploys to QASame artifact to production
One Power Platform pipelines deployment: publish, request, export once, prevalidate, then promote the same managed artifact from QA to production

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 pointCode componentClient scriptingDataverse plug-inCustom connector
What it extendsThe user interface: a control the standard controls cannot provideModel-driven form behavior in the browserServer-side processing of a Dataverse data operationAccess to an external API as actions and triggers
Runs whenThe control renders on a form, view, dashboard or canvas screenA form event fires: the form loads, a column changes, or the form is savedA registered Dataverse event occurs, synchronously or asynchronouslyAn app, flow or agent calls one of its operations
Where it can be usedModel-driven and canvas appsModel-driven app formsInside Dataverse, synchronously during or asynchronously after the data operationPower Apps, Power Automate, Copilot Studio and Logic Apps
Typical requirementShow a number as a dial or a list as a calendarChange the form when a column changes, beyond what business rules can doValidate or cancel a save, or change the data being savedCall a REST API that has no prebuilt connector
Tempting wrong useChoosing a UI control for connector actions when no custom UI is neededReacting to a data change on the serverRendering an interactive controlIntercepting and cancelling a Dataverse operation

Decision tree

Declarative optionsruled out?NoDeclarativeoptions firstYesNeed a control thestandard set lacks?YesCodecomponentNoChange form behaviorin the browser?YesClientscriptingNoHandle a Dataversedata operation?YesDataverseplug-inNoCustom connector(external API)

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
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
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
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
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
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
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
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
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
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
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
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
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 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
The default environment is tenant-wide and unsuitable as a protected production boundary

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
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
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
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
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
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
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
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
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
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
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 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
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
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
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
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
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
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
All unmanaged customizations share one active unmanaged layer

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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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

References

  1. https://learn.microsoft.com/en-us/power-apps/maker/plan-designer/plan-designer
  2. https://learn.microsoft.com/en-us/credentials/certifications/resources/study-guides/ab-410
  3. https://learn.microsoft.com/en-us/power-apps/maker/plan-designer/create-plan
  4. https://learn.microsoft.com/en-us/power-platform/alm/solution-concepts-alm
  5. https://learn.microsoft.com/en-us/power-apps/maker/plan-designer/build-solution
  6. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/model-driven-app-overview
  7. https://learn.microsoft.com/en-us/power-pages/
  8. https://learn.microsoft.com/en-us/microsoft-copilot-studio/flows-overview
  9. https://learn.microsoft.com/en-us/power-apps/maker/data-platform/create-and-use-dataflows
  10. https://learn.microsoft.com/en-us/power-apps/maker/common/faq-from-filling-assistance
  11. https://learn.microsoft.com/en-us/power-apps/maker/data-platform/create-edit-field-portal
  12. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/add-ai-copilot
  13. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/add-microsoft-365-copilot
  14. https://learn.microsoft.com/en-us/power-platform/admin/configure-relevance-search-organization
  15. https://learn.microsoft.com/en-us/microsoft-365/copilot/microsoft-365-copilot-overview
  16. https://learn.microsoft.com/en-us/power-apps/developer/data-platform/plug-ins
  17. https://learn.microsoft.com/en-us/power-apps/developer/component-framework/overview
  18. https://learn.microsoft.com/en-us/power-apps/developer/model-driven-apps/client-scripting
  19. https://learn.microsoft.com/en-us/connectors/custom-connectors/
  20. https://learn.microsoft.com/en-us/power-apps/maker/data-platform/create-connection-reference
  21. https://learn.microsoft.com/en-us/power-platform/admin/environments-overview
  22. https://learn.microsoft.com/en-us/power-platform/important-changes-coming
  23. https://learn.microsoft.com/en-us/power-platform/admin/managed-environment-overview
  24. https://learn.microsoft.com/en-us/power-apps/maker/data-platform/create-solution
  25. https://learn.microsoft.com/en-us/power-apps/maker/data-platform/preferred-solution
  26. https://learn.microsoft.com/en-us/power-platform/alm/solution-layers-alm
  27. https://learn.microsoft.com/en-us/power-apps/maker/data-platform/solution-layers
  28. https://learn.microsoft.com/en-us/power-apps/maker/data-platform/use-powerapps-checker
  29. https://learn.microsoft.com/en-us/power-apps/maker/data-platform/object-checker
  30. https://learn.microsoft.com/en-us/power-apps/maker/data-platform/solution-history
  31. https://learn.microsoft.com/en-us/power-apps/maker/data-platform/environmentvariables
  32. https://learn.microsoft.com/en-us/power-apps/maker/canvas-apps/connections-list
  33. https://learn.microsoft.com/en-us/power-platform/alm/pipelines