Create model-driven apps
What a model-driven app is made of
Picture a warranty team whose claims already live in a Microsoft Dataverse table (a structured store of rows and columns; designing the tables themselves is covered on the build-data-models page). Put that table into a model-driven app and users get navigation, a list of claims and an editor for a single claim before anyone places a control on a screen. That is the model-driven idea: model-driven app design[1] adds components such as forms, views, charts and dashboards to tables by using an app designer, and relationships between tables let users move between related records. Microsoft suggests thinking of them as data-model-driven apps, because without a data model in Dataverse you can't create a model-driven app at all.
The building blocks
| Component | What it is |
|---|---|
| Form | The editor for one row: its columns, arranged in tabs and sections |
| View | A saved list of rows: the columns to display, the default sort and, where needed, filters that show only matching rows (views on a grid page[2]) |
| Chart | A visualization of the rows a view supplies |
| Dashboard | A page that combines charts, lists and other components |
The app arranges these components into pages and navigation, which the next section describes.
Model-driven apps versus canvas apps
The sharpest difference is who decides the layout. In a canvas app the maker has total control over the layout; in a model-driven app much of the layout is determined by the components you add, the data platform is Dataverse only, and the app is responsive and accessible automatically, according to Microsoft's comparison of the two app types[1]. The Microsoft AB-410 study guide[3] lists canvas apps under a separate skill, Create canvas apps; see Create canvas apps. This page covers model-driven apps, including the two ways canvas-authored content runs inside one: embedded canvas apps and custom pages.
The Create model-driven apps skill and this page's order
The Microsoft AB-410 study guide[3] lists seven bullets under Create model-driven apps (Create intelligent applications, 25–30%). This page takes them in build order: "Compose a model-driven app"; "Create and configure forms for model-driven apps"; "Create and configure views for model-driven apps", with the grid that displays views; "Create generative pages by using natural language", alongside commands and custom pages; "Create and configure model-driven app charts and dashboards"; then "Configure access to forms and views for model-driven apps" and "Configure access to model-driven apps". Throughout, a requirement in a scenario primarily maps to components and settings, and learning that mapping is the point of every section that follows.
Composing the app in the app designer
Composing a model-driven app means deciding which pages it has, how its navigation groups them, and which of each table's forms, views and charts it includes. All of this happens in the model-driven app designer[4], whose preview reflects each change instantly.
Pages
Add page creates a new page, which can hold a table's forms and views, a table dashboard, or a custom page; generative pages are added from the same command (see Generative pages: describe, generate, refine below). When you select a table in the Pages pane, the property pane shows the forms and views associated with that table. Adding a table therefore starts the experience rather than finishing it: you still choose which of the table's forms, views and charts this app uses.
Navigation: areas, groups and subareas
The Navigation section of the Pages pane lays the app out in three levels: an area holds groups, a group holds subareas, and subareas are the navigation entries that lead to pages such as a table's list or a dashboard. Two navigation settings shape this hierarchy:
- Enable Areas is off by default and must be on before you can add more areas. Apps that already have multiple areas have it on, and you can't turn it off while the app has more than one area.
- Enable collapsible groups is also off by default; turned on, it lets users expand and collapse the subareas under each group.
Navigation belongs to the app, so reorganizing it is app designer work. Form tabs look similar but organize the fields of one table's form, not the app's navigation. An area holds groups and a group holds subareas, as the figure below, placed at the end of this section, shows for an example sales app: a Sales area holds a Customers group (the Accounts and Contacts subareas) and an Insights group (a Dashboards subarea). These are example names, not required ones.
App inclusion: which forms, views and charts the app offers
Select a table's form page and the right pane lists the forms In this app and Not in this app, each with ... > Add or Remove (add or remove forms, views, or charts[5]). Views and charts work the same way through the Views and Charts tabs of the table's view page. By default all forms, views and charts are selected; selecting specific ones narrows the app to only those components. This is app inclusion, one of the four access layers this page uses to diagnose access (see Four questions for diagnosing access). It changes the list of components the app offers, never the records a view returns: removing a view from the app is different from editing that view's filter, which changes the rows the view returns wherever it is used.
Save, Publish and Play
Save stores your edits, Publish makes the changes available to other users, and Play opens the app in run mode in a new tab. Because the preview shows changes immediately and Play simply runs the app, neither a good-looking preview nor a successful Play run proves that users can see your changes; only publishing does that. To sum up: compose with pages, navigation and app inclusion, then publish.
The four form types
Every model-driven form is one of four types, and the type, not the layout, decides what the form can do. Choose the type by the job the user is doing:
| Form type | The user's job | Where it appears |
|---|---|---|
| Main | View and edit one row completely | The record page; users switch among eligible main forms in the form selector |
| Quick create | Enter a new row quickly | The Create button on the navigation bar, or + New on a lookup or subgrid |
| Quick view | Read a related row without leaving the current one | Inside a main form, through a quick view control bound to a lookup |
| Card | Scan rows compactly | Inside a view, as a card per row |
A lookup is a column that points to a row in another table, such as an account's primary contact, and a subgrid is a list of related rows shown on a form, such as the contacts of an account.
Main forms
Main forms are used when working with and editing a specific record's data (design productive main forms[6]). The form header shows the table and record name, the selector for switching to another form of the table, up to four read-only fields of the record, and the form's tabs; the body below holds the fields and related records needed for the task. Forms appear in the form selector only if they have been enabled (made active; see Making a form unavailable) and added to the app. Main forms are also the only type of the four that can be assigned to security roles (a security role is a Dataverse bundle of privileges that define the actions users can perform on the app's tables, per share a model-driven app[7]; see Controlling which main form users get).
Card forms
A card form presents a row as a compact card inside a view instead of as a grid row. When a view or subgrid is narrow, the Power Apps grid control[8] switches to a card list format suited to small screens such as mobile devices, but its list view doesn't display a table's custom card forms. To show a custom card form, configure the table to use the legacy Read Only Grid control and set that control's Card Form property to the card form. A custom card form therefore reaches users through a grid control setting, not by being chosen like a main form. A card can also appear in a related-record subgrid on another form; it is not limited to standalone views.
In short: main forms edit a whole row, card forms condense rows in a view, and the two specialized types follow next.
Quick create forms
Quick create forms give users a short, streamlined form for adding a row without leaving what they were doing, and they still support form scripts and business rules (create or edit quick create forms[9]). Form scripts are JavaScript that runs on form events (configure form event handlers[10]); business rules apply logic and validations without code (create a business rule[11]). They appear when a user selects Create on the navigation bar, or + New while creating a row from a lookup or a subgrid. Microsoft's productive-forms guidance lists typical uses: creating an appointment from the timeline (the list of a record's activities such as emails, calls and notes), creating a contact from a lookup when a full main form dialog (the related row's whole main form opened as an overlay) isn't needed, or creating a record that doesn't need additional relationships (design productive main forms[6]).
What it takes to make one available
Three things must all be true: the table has Enable quick create forms turned on, the table has been added to the app, and a quick create form exists (New form > Quick create form, then Save and publish). Creating the form alone completes nothing if either of the first two is missing.
A fixed shape
A quick create form always has one section with three columns, and you can't add more sections or columns. These controls can't be added to it at all: subgrids, quick view forms, web resources (files such as images or scripts stored in Dataverse), iframes, notes and Bing Maps. A requirement for a multi-section editor or a list of child rows therefore points to a main form or a main form dialog (next section), never to quick create.
One form for everyone
A table can have several quick create forms, but only one is used by everyone, and the form order decides which one. Quick create forms can't be assigned to security roles, and users can't switch between them, so departments that want different entry forms can't be served with role-specific quick create forms.
Excluding it from the app doesn't hide it
Microsoft's guidance is that if you don't want a quick create form to appear in your app, you must delete it. Check this distinction before excluding the form: the table must be in the app, but including the form doesn't govern this behavior; if a quick create form exists for a table but isn't included in the app, the Unified Interface runtime (the client that runs model-driven apps) still opens it from lookup controls and subgrids. The form is defined on the table rather than inside one app, so check the other apps that use the table before deleting it.
The pattern to remember: enable it on the table, include the table in the app, keep it to one section, and delete the form (rather than exclude it) to stop it appearing.
Showing and editing related rows on a form
A main form often needs data from another table, such as the primary contact on an account. Model-driven forms offer four surfaces for a related row, and they differ in one thing: how much of the related row users can work with without navigating away (design productive main forms[6]).
| Surface | What users can do with the related row |
|---|---|
| Quick view form | Read selected columns, read-only |
| Reference panel | Browse read-only lists of records from several related tables |
| Form component control | Edit the related row's form fields inline |
| Main form dialog | Work with the related row's whole main form |
A reference panel offers only read-only lists of related records, so the comparison table and decision tree near the end of this page leave it out: they compare the other three surfaces with quick create forms and embedded canvas apps.
Quick view forms: read-only, bound to a lookup
A quick view form is placed on a main form as a quick view control associated with a lookup column on that form, and you can add one only when a lookup on the form targets the quick view form's table (create a quick view form[12]). If the lookup has no value, the quick view control isn't visible. Users can't edit data in it, and it doesn't support form scripts. Its layout is deliberately small: one single-column tab, to which you can add only single-column sections, columns, subgrids and spacers, with no header, footer or navigation areas. Custom controls aren't supported and complex controls such as subgrids have limited customization support; when that is required, Microsoft points to the form component control. Quick view forms also can't be assigned security roles and can't be activated or deactivated.
Reference panels: several related lists, still read-only
A reference panel gives quick access to lists of related records beyond one table, for example contacts, opportunities and leads side by side. It only provides read-only views of records and doesn't support a related record's main form the way a main form dialog or a form component does. It is currently added through the classic form designer.
Form component control: edit the related row inline
When users need to edit a related row on the current form but shouldn't navigate to it, a form component control embeds the related row's form, including all its sections, controls and fields. It honors that form's events and business rules, and it promotes unsaved changes to the hosting main form, notifying users when a field is required and when there are data entry errors on the related form.
Main form dialog: the whole related record
When users need everything on the related row, including its tabs, timeline activities, related records or a business process flow (a guided sequence of stages for a record, taught on the implement-business-and-process-logic page), open its main form as a dialog. A main form dialog can be configured directly from the lookup control, and it opens as a modal overlay positioned on the left, middle or right of the page.
The rule to carry: read-only needs a quick view form, inline edits need a form component control, and the full record needs a main form dialog.
Embedding a canvas app on a form
Sometimes a form needs something no standard control provides, such as a map of a customer's sites drawn from another system, shown beside the Dataverse fields. An embedded canvas app is a canvas app placed on a model-driven form, its host form: canvas apps can connect to a wide range of data sources, and the embedded app can use the host form's row with functions such as Filter, Search and LookUp to find related data in those sources (add an embedded canvas app on a model-driven form[13]).
Two ways to embed, only one of which integrates
Both the modern and the classic form designers can add an existing canvas app through the Canvas app control, but currently only the classic form designer can create a new canvas app to embed, by selecting Customize on the control's properties. The difference matters because access to the host form's data through the ModelDrivenFormIntegration control (next section) works only for an embedded app created that way; apps that were merely added don't currently support the integration. A third, more recent method, custom pages, is covered in Custom pages below.
Classic setup rules
- Bind to a column that always has a value. The control is added to a column on the form, and that should be a required column guaranteed to contain a value, such as Account Name. If the column has no value, the embedded app won't refresh in response to data changes on the host form.
- App name first, then App ID. The control looks for the app first by the unique name in App name; only if no app with that unique name exists in the environment does it use App ID. Both fields must be filled in, but only one needs to be accurate. The unique name is not the display name: it appears in the Name column of a solution (the container of customizations through which Power Apps implements application lifecycle management, per solution concepts[14]) in the form publisherprefix_appnamenospaces_suffix. Microsoft recommends setting App name so that the app is referenced correctly when it moves between environments in a solution.
- Same environment. The canvas app must be in the current environment. If neither App name nor App ID matches an existing app, the form shows Sorry, we didn't find that app.
- One per form. The classic designer allows only one enabled canvas app on a form at a time.
Access to the host form doesn't give users the embedded app; it has its own sharing step, covered in Sharing the app and the parts it depends on. To sum up: create the app from the classic designer when it needs the host row, bind it to an always-populated column, and when it can't be found, check App name, App ID and the environment.
The ModelDrivenFormIntegration control
A canvas app created for a form through the classic designer contains a special control named ModelDrivenFormIntegration, which brings contextual data from the host form into the app and lets the app act on the host form (ModelDrivenFormIntegration properties and actions[15]). Its members work in two directions, host to app and app to host, and the figure below draws both.
Host to app: properties
| Member | What it does |
|---|---|
DataSource | Refers to the table of the host form; set automatically when you create a new embedded app. Never filter or modify it. |
Item | Read-only access to the host form's row, for example ModelDrivenFormIntegration.Item.'Account Number' |
OnDataRefresh | A formula evaluated when the host form saves data |
Data | Used by the framework; don't use it, use Item instead |
Keep DataSource pointing at the host form's table even when the app displays related child rows, so that the control keeps its connection to the correct parent table. Item has a timing catch: it isn't guaranteed to contain data when the app starts, so logic that needs the host row should wait for it, for example by testing !IsBlank(ModelDrivenFormIntegration.Item) before using the row.
OnDataRefresh formula from Microsoft's example
// Runs each time the host model-driven form saves data
Refresh(Accounts);
Set(CurrentAccountNumber, ModelDrivenFormIntegration.Item.'Account Number')
This is the complete formula for the OnDataRefresh property in the table above: Accounts is the app's data source for the host form's table, and the comment line is valid Power Fx (the low-code formula language canvas apps use). Microsoft recommends using OnDataRefresh only to refresh data inside the embedded app, not to save changes made in it.
App to host: actions
The control also exposes actions that run on the host form (perform predefined actions on the host form[16]):
| Action | Effect on the host |
|---|---|
SaveForm() | Saves the data on the host form |
RefreshForm(showPrompt) | Refreshes the data on the host form; showPrompt says whether to ask before saving unsaved host data |
NavigateToMainForm(entityName, mainFormName, recordId) | Opens the named table's main form and displays the specified row |
NavigateToView(entityName, viewName) | Opens the named view of the table |
OpenQuickCreateForm(entityName) | Opens the table's default quick create form |
The last three are the host navigation actions. Every action targets the model-driven host, which is why the canvas look-alikes fail: SubmitForm submits a canvas Edit form's own data rather than the host's unsaved fields, Navigate changes the canvas app's screen, and NewForm switches a canvas form into new mode without opening the model-driven quick create form. Likewise, refreshing the embedded app's data source with Refresh is not RefreshForm, which refreshes the host.
The takeaway: read the host through Item once it is ready, react to host saves in OnDataRefresh, and act on the host only through the control's actions.
Views and the default view
Views are how a model-driven app lists rows. A view consists of the columns to display, the default sorting and, where needed, filters that show only rows matching specific criteria (create and manage personal views[2]). Users pick among the available views in the table's view selector.
Personal views and system views
| Kind | Created and owned by | Visible to |
|---|---|---|
| Personal view | An app user | Only its creator, unless they share it |
| System view | An administrator or maker | Everyone, by default |
System views come in several types: Public, Quick Find, Advanced Find, Associated and Lookup (manage access to public system views[17]). A view that a maker creates in Power Apps becomes a public view, the general-purpose type users choose from the view selector. The other types serve specific purposes such as search results, related-record lists and lookup pickers, and they are not substitutes for public views. Expect the names to overlap: Microsoft's documentation often says system views when it means these public views, and in Power Apps they show the view type Public.
The default view
Each table has a default view, set by an administrator, which the view selector labels Default and which users see first. A user can override it with a personal default for themselves (next section). That is why changing the table's default public view is the wrong fix for one person's preference: it changes the shared default for users without a personal override.
Which views an app offers
By default every view is included in the app; selecting specific views on the table's Views tab narrows the list, as described under App inclusion in Composing the app in the app designer. Narrowing the list removes choices without touching any view's definition, whereas editing a public view's filter changes the rows it returns.
So: makers manage public views, the table's default view and app inclusion; users own their personal views.
Personal views at run time
Users can reshape a list for themselves without touching what makers built, because personal views are available only to their creator unless that user shares them (create and manage personal views[2]).
Saving edits
When a user changes a view's columns, filters or column widths, an asterisk beside the view name shows that the edits aren't saved; switching to another view or leaving the page reverts the view to its original definition. Two save paths exist:
- Save as new view keeps the original and stores the edits as a separate view. It is the only option when the user lacks Write permission on the view, whether it is a system view or a personal view. Give the new view a different name: saving under the existing name overwrites that view without confirmation.
- Save changes to current view replaces the original definition and needs Write permission on that view.
Personal default view
Set current view as my default changes the first view a user sees for the table without changing the administrator's default, and Reset default view returns the user to the administrator's choice.
Managing views with modern advanced find
When an administrator turns on modern advanced find (an environment setting that adds view management to the view selector), Manage and share views offers the actions below. What separates them is who they affect:
| Action | Affects | Available on |
|---|---|---|
| Hide | Only this user, in that table's view selectors across all model-driven apps and devices | Personal views by default; system views only if the administrator allows it |
| Share | Grants other users access | Personal views the user has Share permission on |
| Assign | Transfers ownership to another user or team | Personal views the user owns |
| Delete | Everyone who has access to the view | Personal views the user has Delete permission on |
| Deactivate | Everyone who has access to the view | Personal views the user has Write permission on |
Two misreads follow from the table. Assign is not how you give colleagues a view: it moves ownership, while Share grants access. And deleting a shared personal view to tidy one person's selector removes it for everyone; hiding is the per-user action. Two hiding rules also apply: a table's default view can't be hidden until another view is set as the default, and a hidden view can't be set as the default.
The takeaway: unshared personal views, personal defaults and hiding are per user, while delete and deactivate reach everyone with access.
Configuring the Power Apps grid control
The Power Apps grid control is the grid in which users read and edit lists of rows. It supports both read-only and inline-editing experiences, infinite scrolling, nested grids, grouping and aggregation, and it eventually replaces all read-only and editable grids in model-driven apps (Power Apps grid control[8]).
Table or subgrid: where you configure it
Configured on a table (through the classic solution explorer), the control applies to all views of that table. Configured on a subgrid in the form designer, it affects only that subgrid on that form. Either way, it starts read-only until you configure editing.
The properties that shape behavior
The table lists the properties that most often decide a scenario; others, such as filtering, sorting, multiselect and the jump bar, also exist.
| Property | Default | What changes |
|---|---|---|
| Enable editing | No | Yes makes the grid editable inline |
| Enable pagination | No | No gives infinite scrolling; Yes shows paging buttons instead |
| Enable grouping | No | Yes lets users group rows by a column |
| Enable aggregation | No | Yes offers sum, minimum, maximum or average on numeric columns |
| Reflow behavior | Reflow | Grid only, List only, or switching between them with the available width |
| Navigation types allowed | All | Primary only keeps links on the primary column only; None removes all grid hyperlinks |
| Child items, Child items parent ID | None configured | Together they create nested grids |
| Disable editing in child items grid | No | Yes stops editing in a nested grid whose parent grid is editable |
Interactions to remember
- Grouping and pagination conflict. Grouping isn't supported when paging is enabled, so a requirement for grouped rows keeps Enable pagination at No.
- Grouping is temporary and single-column. Users group by one column at a time, and choosing another column replaces the existing grouping. Lookup columns can't be grouped, and the grouping isn't saved to the view (explore data in a view[18]).
- Aggregation is its own switch. Turning on grouping doesn't expose totals; Enable aggregation does, and once rows are grouped the aggregate is shown for each group as well. Aggregations aren't saved to the view either.
- Nested grids need both halves. Child items names the related table and the view that defines the nested grid's filters, sorts and columns; Child items parent ID names the column (and relationship) that links parent and child rows. The nested grid inherits the parent grid's editability unless Disable editing in child items grid is Yes.
- Responsive layout is Reflow behavior, not pagination. Reflow switches between a table and a list (the card list format described under Card forms) as the available width changes; pagination only changes how users move through rows.
- Links are controlled without changing columns. Navigation types allowed suppresses hyperlinks while the view keeps all its columns.
In short: configure the grid at table level for every view or at subgrid level for one form, and remember that editing, grouping and aggregation all start switched off.
Modern commands on the command bar
Commands are the buttons on a model-driven app's command bars and the actions behind them. A modern command, built in the command designer, separates three concerns: display (the label, icon and position on a command bar), action (the logic that runs when the button is selected) and visibility (the conditions under which the button shows) (modern commanding overview[19]).
Pick the table and the command bar location
In this table-based command-designer workflow, each command belongs to a table and to one command bar location:
| Location | Where users see it |
|---|---|
| Main grid | The full-page list of the table's rows, opened from the app navigation |
| Main form | The top of the table's main forms |
| Subgrid view | Other tables' forms that show this table's rows in a subgrid |
| Associated view | A parent row's form, when users open this table's related rows |
The table is the one whose rows the bar acts on, not the table of the form the bar sits on. To change the buttons above the contact subgrid on an account form, edit the contact table's Subgrid view command bar; the account table's Main form bar is a different location on a different table. Quick actions belong with the main grid location: the first five main grid commands, determined by order, are also shown as quick actions when users play the app (command bar locations[19]). Less common command bar locations aren't supported in the command designer.
Power Fx for action and visibility
Modern commands support Power Fx for both actions and visibility. Classic commands, formerly called the ribbon and customized by hand-editing XML in solution files, don't support Power Fx at all. The command's host supplies a Self.Selected property describing what the user selected (use Power Fx with commands[20]):
| Field | Meaning |
|---|---|
Self.Selected.Item | One selected record; blank when nothing is selected, and always blank when the command's SelectionMax (its selection limit) isn't 1 |
Self.Selected.AllItems | All selected records, as a table |
Self.Selected.State | The state of the selected control: Edit, New or View |
Two visibility formulas built from those fields
// Command A: show only when more than one record is selected
CountRows(Self.Selected.AllItems) > 1
// Command B: show only on a form that is creating a new row
Self.Selected.State = FormMode.New
These are two separate formulas for two commands; each goes in its command's Visible property after you choose Show on condition from formula. Counting selected records says nothing about form mode, so a create-only button needs the State test, not a count, and multi-record logic must use AllItems, because Item is blank whenever the command allows more than one selection.
Scope and sharing
Commands created with the command designer are visible only within the selected app, so adding the same table to another app doesn't bring them along. Commands without Power Fx follow standard Dataverse role-based security, but Power Fx commands also require the command component library (the component library that holds the app's command formulas) to be shared with users, in addition to an appropriate security role.
The takeaway: choose the table and location first, write action and visibility in Power Fx, and share the command component library along with the app.
Custom pages
A custom page is a page type within a model-driven app that brings canvas app capabilities into it: authored in Power Apps Studio with low-code expressions, it can serve as a full page, a centered or side dialog, or a page in the app side pane on the right of the app (overview of custom pages[21]). A custom page can include one or more tables and can use Dataverse and all of the Power Apps connectors.
Custom page or embedded canvas app
Both run canvas-authored content inside a model-driven app, but they differ in where they can appear, how tightly they integrate and how they are shared:
| Aspect | Custom page | Embedded canvas app |
|---|---|---|
| Where it runs | A full page, a dialog or the app side pane | Only on a model-driven form |
| Integration with the app | Joins the app's navigation (the sitemap), opens from model-driven pages through navigateTo, a method of the Client API[22] (the objects and methods JavaScript code uses in model-driven apps), and moves to forms, views, dashboards or other custom pages with the Power Fx Navigate function; this integration addresses the embedded-app count limit | Acts like a low-code component on a form; its simpler hosting keeps the limit on how many can be embedded |
| Sharing for app users | Through the model-driven app; pages aren't shared individually | Its own explicit sharing |
By contrast, in an embedded canvas app Navigate changes only the canvas screen, so that app uses the host navigation actions (see The ModelDrivenFormIntegration control).
Microsoft's guidance is to use custom pages instead of embedded canvas apps in most cases, for tighter integration and better performance. A requirement for an app-level side pane rules out an embedded canvas app outright, because an embedded canvas app can only be placed on a form.
Building and sharing
Custom pages are created from a solution, either in the modern app designer or through New > Page in the Solutions area. Each custom page is a separate solution component, so one maker edits one custom page at a time. App users don't need the page shared with them: custom pages rely on the model-driven app's sharing, although makers might need the page shared with them to edit it. Microsoft also advises keeping an app to no more than 25 custom pages, because more can lengthen the first launch after each publish.
In short: a custom page is a canvas-authored page inside the app, placed where the app needs it and shared with the app.
Generative pages: describe, generate, refine
A generative page is a page in a model-driven app that an AI agent builds from your description: you describe the page in natural language, choose the data it uses, optionally attach an image, and the agent generates React code covering both the user interface and the business logic (generate a page using natural language[23]). Generative pages are currently supported only in model-driven apps, not in canvas apps.
Two authoring routes
Microsoft supports two authoring experiences that produce the same kind of page. AI code generation tools, GitHub Copilot CLI among them, work from a local development environment and are available worldwide on public clouds. The in-browser experience in Power Apps requires an environment located in the United States, Great Britain, Australia or Singapore, and supports only US English as the prompting language. The rest of this section describes the in-browser route.
The in-browser workflow
- In the app designer, select Add page > Generative page, then Describe a page. The same dialog lists existing generative pages in the environment, filtered to Published by default; switch the filter to All to find an unpublished one.
- Describe the page: its functional requirements and any user experience specifications. A prompt can be at most 50,000 characters.
- Add data with Add data > Add table; one page can link up to six Dataverse tables. A page can also reference Power Platform connectors and Dataverse custom APIs, both in preview (generate a page using natural language[23]; see Connectors and custom APIs (preview) in the next section).
- Optionally attach an image, anything from a napkin sketch to a high-resolution mockup, to guide the layout or visual style.
- Select Generate page. The agent outlines its interpretation and plan, writes the code, transpiles it and renders the result.
- Refine, as many times as needed, by chatting with the agent or by editing the code on the Code tab. Saving a manual edit commits it as a new iteration, and Compare shows a diff between iterations, starting with the second iteration in the current session.
- Save keeps your progress; Save and Publish publishes all pending changes for the app, including generative pages.
The figure below traces the same path, including the loop back from refinement to generation.
An attached image is design guidance, not page content
The attachment tells the agent what the page should look like; it doesn't become an image that the finished page displays. To show a specific image in the page, store it in a Dataverse table the page references, host it at a public URL, or add it as a web resource, and tell the agent where to get it.
Validating what was generated
After each iteration the Accessibility assistant scans the generated code, and Auto fix passes any violations to the agent to try to resolve. That is help, not approval: the agent makes a best-effort attempt at production-ready code, but you are responsible for validating that the code meets your organization's standards and compliance requirements, so review and test it before publishing. Only one maker should work on a generative page at a time, because collaboration isn't supported.
The takeaway: describe, link up to six tables, generate, refine, validate, then Save and Publish.
Generative pages: inputs, form embedding, data, localization and limits
Once a generative page exists, what remains is the context it receives through input parameters, embedding it in a form, the connector data and custom APIs it can reach, localization for multilingual users, and its limits.
Input parameters
A generative page can accept the input parameters recordId, entityName and data, so it can receive contextual data when users navigate to it (generate a page using natural language[23]). You don't wire them by hand: describe in the prompt what the page should accept and how to use it (for example, accept an account recordId and load that account's details when the page opens), and the agent generates the initialization code.
Embedding a page in a form
To show a record-aware generative page inside a form, first create and publish a page set up to accept recordId. Then, in the form designer, open Components > Display, add Generative page and select the page. When a user opens a record, the host form automatically passes the current record ID to the page as recordId, so you don't configure a static value for it; hard-coding one would tie the page to a single record. Values for any other inputs the page accepts can be supplied as static inputs in the same place.
Connectors and custom APIs (preview)
Connector support and custom API support for generative pages are preview features, which Microsoft says aren't meant for production use.
- Connector data. First create and authenticate a connection, then create a connection reference (a solution component that points to a connection) that uses it. In the designer, choose Add data > Connectors, select that prepared connection reference, and describe in the prompt how the page should use the data. Choosing a connector without a prepared connection reference supplies no authenticated connection.
- Custom APIs. A Dataverse custom API is a named server-side operation, commonly implemented by a plug-in (server-side code that runs in Dataverse). Add one with Add > Custom API when the page must invoke a named operation at a specific moment, such as an Approve button that calls an
ApproveOrderAPI, and describe in the prompt what triggers the call, which values to pass and how to use the response. Plug-ins that run automatically when a row is created, updated or deleted already run when the page performs those data operations, so they don't need to be added as custom APIs. Custom APIs run in the context of the signed-in user and are subject to Dataverse security.
Localization
A multilingual page needs explicit prompt instructions: name the languages, ask for a translation dictionary covering all user-visible text, ask for right-to-left layout support if a language such as Arabic or Hebrew is included, and ask for dates, numbers and currency formatted from each user's Dataverse settings rather than hard-coded formats. The page's sitemap entry isn't localized by default and is handled separately in the app designer.
Limits worth knowing
| Limit | Value |
|---|---|
| Dataverse tables linked to one page | Up to six |
| Prompt length | At most 50,000 characters |
| Prompting language in the browser | US English only |
| Makers editing a page at once | One; collaboration isn't supported |
In short: describe the inputs, let the host form pass recordId, prepare a connection reference before adding connector data, and add a custom API only for a named operation.
System charts
A system chart summarizes the rows of a view as a picture. System charts are organization-owned, which makes them available to anyone running the app who can read the data, and they can't be assigned or shared with specific app users (create or edit a system chart[24]). The chart designer described in that article is marked as a preview feature.
Series, aggregation and category
Every chart answers one question: what quantity, grouped by what?
- The series is the column you choose first, the quantity on the vertical axis, together with an aggregate that says how to summarize it. Count shows the number of records, Sum the total, Average the average, Max the highest value and Min the lowest.
- The category is the column whose values form the groups along the horizontal axis.
Choose the aggregate from the business question, not from the chart shape. Total revenue per account is Sum of revenue; Count of revenue counts the revenue entries instead of adding their amounts.
Nonnumeric series columns support only Count: All and Count: Non-empty, while numeric columns add Average, Max, Min and Sum. Count: Non-empty is the choice when blank values must not be counted. Min, Max and Average ignore NULL values but include zeros, so a missing value and a recorded zero move an average differently.
Top, Bottom, stacking and comparison
- Top/Bottom rules filter the chart to the highest or lowest results of the selected aggregation. Bottom 1 on Sum of revenue shows the single account with the lowest total revenue, not the single smallest transaction.
- Stacked and 100% Stacked are available only for bar, column and area charts.
- A comparison chart groups by more than one category: up to two category items with one series item.
Views, volume and the app
- Previewing a chart with a view doesn't permanently associate that view with the chart; the chart can display data from a different view, so read its numbers in the context of the view supplying the rows.
- Charts display views that return up to 50,000 records. A larger view shows The maximum record limit is exceeded. Reduce the number of records. The fix is a view that returns fewer rows, because changing the chart type leaves the input unchanged.
- An app that isn't set to show All charts for a table needs each new chart selected in the app designer (see App inclusion in Composing the app in the app designer), and the app saved and published. For a published chart missing from one app, check whether it is selected in that app.
The takeaway: the series and its aggregate are the quantity, the category is the grouping, and the view supplies the rows.
Standard and interactive dashboards
Dashboards are collections of charts and other components relating to Dataverse tables, and they vary along two independent axes: who owns them, and how interactive they are (create or edit dashboards[25]).
User and system dashboards
A user dashboard is created by an app user and is visible only to them unless shared, in the app areas where they have privileges. A system dashboard is created or customized by an administrator or customizer, and a published standard system dashboard is visible to all app users (create or edit dashboards[25]). Interactive dashboards differ: they are security-role based, so each one can be limited to selected security roles (interactive experience dashboards[26]; see Interactive dashboards below). A user can set their own dashboard as their default, overriding the system dashboard for themselves, which is the right answer when one person wants a different starting dashboard.
Standard dashboards
A standard dashboard combines one or more unrelated components, such as charts or lists, up to six of them, in a 2-, 3- or 4-column layout. Adding a chart component asks for a Record Type, a View and a Chart, so each component defines both the visualization and the rows behind it. A Power BI embedded option sits beside these layouts (see Power BI content in model-driven apps).
Interactive dashboards
An interactive dashboard is a workplace where users, such as service representatives, see workload information in real time and act on a record directly from the dashboard instead of paging through the app (interactive experience dashboards[26]). Its building blocks:
- Streams list work items. A stream's data comes from one table, through a view or, for queue-enabled tables, a queue (a list of work items waiting to be handled). If a table isn't queue enabled, the Queue option doesn't appear and the stream must use a view.
- Interactive charts count relevant rows and also act as visual filters.
- Filter Table sets the table on which the visual filters and global filter attributes are based, and the global filter also applies to streams and tiles based on that table. Filter By chooses the date column the timeframe filter applies to, and Time Frame sets that filter's default value. To filter on a different date column, change Filter By, not Time Frame.
Interactive dashboards come in two forms. A multi-stream dashboard shows several streams, and each stream can be based on a different table; it can be a home page (general) dashboard, or a table-specific dashboard whose streams are all based on that one table. A single-stream dashboard shows one stream based on a view or a queue, with optional tiles on the right. The figure below arranges these kinds by interactivity.
To limit an interactive dashboard to selected security roles, select it, choose Enable security roles, select Display only to these selected security roles with the roles you want, and publish. This is role targeting, one of the four access layers (see Four questions for diagnosing access).
In short: standard dashboards assemble up to six components, and interactive dashboards let users act on streams of work.
Power BI content in model-driven apps
Two of the paths that bring Power BI content into a model-driven app are an app-wide system dashboard and a user's personal dashboard (Power BI embedded in a form, mentioned below, is another), and they differ in scope, in setup and in which environment setting governs them.
App-wide: a Power BI embedded system dashboard
A system administrator or system customizer creates a system dashboard that references a Power BI report or dashboard (create a Power BI embedded system dashboard[27]). In a solution, select New > Dashboard > Power BI embedded, then choose the type (Power BI report or Power BI dashboard), the Power BI workspace and the report or dashboard. Selecting Use environment variable stores the workspace and report as an environment variable, so the reference can differ per environment when the solution moves. Add the dashboard to the app with Add page > Dashboard, set the System dashboards picker to Power BI dashboards, select it, and then save and publish. Users still need the relevant Power BI license and authorization to see the content.
Personal: Power BI tiles on a user's own dashboard
A user can add an individual Power BI tile to a personal dashboard, beside charts and lists, by selecting an area of the dashboard and choosing Power BI Tile; a whole Power BI dashboard can also become a personal dashboard (add Power BI visualizations to your dashboard[28]). This requires three things: Power BI visualizations enabled for the organization, a Power BI account with access to at least one Power BI dashboard, and third-party cookies enabled in the browser, without which authentication to Power BI fails.
Sharing such a personal dashboard requires sharing in both Dataverse and Power BI, and the recipients need appropriate access in both services. A dashboard that opens for a colleague therefore doesn't prove they can see its Power BI visuals.
Which setting governs which path
The Power Platform admin center's Power BI visualization embedding environment setting controls whether end users can add embedded Power BI reports to personal views, charts and dashboards. Power BI embedded in a system dashboard or a form ignores that setting, so turning it off doesn't remove a system dashboard's Power BI content.
The takeaway: an app-wide report page is a Power BI embedded system dashboard, while personal tiles live on user dashboards and depend on the embedding setting and on sharing in both services.
Four questions for diagnosing access
App sharing, app inclusion and role targeting decide what a user is offered; only data privileges secure data. Access in a model-driven app can be reasoned about using four diagnostic questions about the app experience, rather than a sequence a user must pass before a record appears; this page calls the four controls behind them access layers. Model-driven apps use role-based security for sharing, in which a security role contains privileges that define a set of actions that can be performed on tables within the app (share a model-driven app[7]). One security role serves two of the questions below: question 1 asks whether the app is shared with it, question 4 which table privileges it holds, so sharing the app[7] alone does not secure records.
- App sharing: may this person open the app at all? The app must be shared with their security role, with them or with their team, and they must be a user in the environment who meets applicable licensing requirements (share a model-driven app[7]).
- App inclusion: does this app contain the component? This is set in the app designer (see Composing the app in the app designer).
- Role targeting: is this component offered to the user's security role? Main forms, nondefault public views and interactive dashboards can each be limited to selected security roles; a published standard system dashboard is visible to all app users.
- Data privileges: which records may the user read or change? The privileges in the user's security roles decide this for each table, independently of the form, view or dashboard in use (manage access to public system views[17]).
So hiding a view from a role never protects the records it lists (see Role-based access to public views). The Microsoft AB-410 study guide[3] lists "Configure security" under Build data models (Create a foundation for intelligent applications, 25–30%); see Build Dataverse data models.
Preferences sit outside the layers. Form order, a table's default view and a user's personal default only choose which of the allowed components opens first, and none of them restricts anything. The figure below draws the four questions in diagnostic order, not a runtime request order, with the data layer styled differently because it is the only one that secures records.
The takeaway: use these four questions as an initial diagnostic aid for an access problem, not a complete checklist.
Controlling which main form users get
When a table has several main forms, three form settings decide which one a user works in: security roles, the fallback form and the form order (manage model-driven app forms settings[29]). The figure below shows the whole sequence in order: the candidates are the active main forms included in the app, security roles narrow them, the fallback form or the form order picks one, and a form the user then selects stays their default.
Security roles: who is eligible
In a main form's Form settings, Security role offers Everyone or Specific security roles. Assigning specific roles is how different groups get different main forms for the same table. Only main forms can be assigned to security roles; quick create, quick view and card forms can't.
Fallback form: the safety net
Because every table must be able to display a form for any user, at least one main form must be a fallback form, which is shown to users whose security roles have no form explicitly assigned. Fallback applies only to main forms. Microsoft describes two strategies:
- A contingency form shows minimal information and is assigned to no role except System Administrator, so users without a matching role see little, and the form can explain how to request access.
- A generic form is the least specialized form, displayed for everyone and used as the fallback, with role-specific forms ranked above it in the form order.
Form order: which eligible form opens first
The form order ranks forms and determines which of the available forms is shown by default. It doesn't decide who can view a form; that is the job of the form's security roles. And once a user selects another eligible form in the form selector, that form remains their default until they select a different one, so reordering forms doesn't reset users' own choices.
Making a form unavailable
To stop everyone from using a main form while keeping its definition, make it inactive: main forms support active and inactive states. Moving an obsolete form to the bottom of the form order leaves it available to eligible users. When a form a user expects is missing from the selector, check both its state and app inclusion, because forms appear in the form selector only if they have been enabled and added to the app (design productive main forms[6]).
The takeaway: security roles decide eligibility, the fallback form catches users with no match, the form order picks the default, and the inactive state removes a form.
Role-based access to public views
Public views can be targeted at security roles, so each team's view selector shows the views relevant to it; Microsoft calls this managing table list views (manage access to public system views[17]).
Prerequisites
The environment's EnableRoleBasedSystemViews database setting (an orgdbsettings property changed with the OrganizationSettingsEditor tool) must be true, and the person configuring the feature needs the System Administrator security role in the Dataverse environment. Turning on auditing is recommended but not required. Until views are assigned to roles, all system views are available to everyone.
Assigning roles to a view
Open the table's Views area, select a nondefault public view, choose View settings > Specific security roles, select the roles and then Save and Publish. Only public views can be managed this way, and the table's default public view can't be assigned security roles. Quick Find, Advanced Find, Associated and Lookup views are not public views and don't stand in for them. The roles listed come from the root business unit (business units are security boundaries that work with security roles to determine a user's access, and every Dataverse database has one root business unit, per security concepts in Dataverse[30]), and users holding the corresponding business-unit-level roles are filtered automatically.
What it does not do
Role targeting here filters one place: the table list view selector. Users can still reach all views through Manage and share views, and subgrids and associated grids that have a view selector keep showing all system and associated views. Records stay secured by security role privileges, so a view a user can see shows only records they can access, and a view a user can't see protects nothing. Role-based views tidy a selector; confidentiality belongs to data privileges, the fourth layer in Four questions for diagnosing access.
When changes take effect
| Change | Takes effect |
|---|---|
EnableRoleBasedSystemViews set to true | Immediately |
| A view assigned to security roles | Immediately after Save and Publish |
| A view changed from specific roles back to Everyone | Up to 24 hours later, or when the user signs out and back in |
In short: enable the setting, assign roles to nondefault public views, and remember that the feature filters a selector without securing data.
Sharing the app and the parts it depends on
Sharing is the first of the four access layers (see Four questions for diagnosing access), and a model-driven app's sharing is built on security roles rather than on the app alone (share a model-driven app[7]). A security role contains privileges that define what a user can do with each table, so two people can open the same app while one reads only the records they created and the other can see and delete every record.
The sharing step
In Power Apps, select Apps, open the app's ... menu and select Share. The Share pane offers two kinds of recipient: all members of one or more security roles, or individual users and teams from the People list. Then select Share.
What sharing does not do
- It doesn't grant custom-table data. If the app uses custom tables, a security role needs privileges on those tables before users can work with their rows. If an app opens but shows no custom-table records, check role privileges and view filters before repeating the sharing step.
- It doesn't send the link. Unlike canvas app sharing, sharing a model-driven app doesn't currently send an email with a link. Copy the Web link (or the Mobile QR code) from the app's Details and distribute it yourself, for example on a SharePoint site. The link is only an address; without the share it authorizes nothing.
Who can share, and who can receive
The sharer must have admin privileges for the environment or be a Power Platform administrator, and must hold a security role with equal or greater privileges than the role being assigned to the app and its users; in practice that is usually System Administrator or System Customizer. Each recipient must exist as a user in the environment, because being a Microsoft 365 user isn't enough, and must meet applicable licensing requirements. When a correctly shared app still won't open, check environment membership and licensing.
The parts with their own access
Several parts of an app need something beyond app sharing; earlier sections explain each, and the table collects them:
| Part of the app | What users need besides app access |
|---|---|
| Embedded canvas app | Explicit sharing with a security group or specific users, read privilege on the Canvas App table, and permissions on its data sources (share an embedded canvas app[31]) |
| Power Fx commands | The command component library shared with them, plus an appropriate security role (see Modern commands on the command bar) |
| Custom pages | No separate sharing of the page for app users: they rely on the model-driven app's sharing (see Custom pages) |
| Power BI content | A Power BI license and authorization; a shared personal dashboard also needs sharing in Power BI (see Power BI content in model-driven apps) |
Check embedded canvas app sharing separately. Access to the host form doesn't share the embedded app, and neither does the Canvas App privilege in a security role: Microsoft states that canvas apps must currently be shared explicitly through app sharing. Sharing an embedded canvas app with Everyone isn't supported with Dataverse and can cause rendering issues, so share it with a security group or specific users.
The takeaway: share with roles or people, give those roles the table privileges, deliver the link yourself, and separately share each part that has its own access.
Form surfaces for new and related rows
| Requirement | Quick create form | Quick view form | Main form dialog | Form component control | Embedded canvas app |
|---|---|---|---|---|---|
| What the user does | Creates a new row quickly | Reads a related row | Works with the whole related record | Edits a related row inline | Uses a custom experience combining several data sources |
| Edits data? | Yes, the new row | No, read-only | Yes, on the related row's main form | Yes; unsaved changes are promoted to the host main form | If created from the classic form designer: reads the host row; its SaveForm action saves the host form |
| Opened from | Create button, or + New on a lookup or subgrid | A quick view control bound to a lookup on the form | A lookup configured to open the related main form as a dialog | The host main form, where it is embedded | The Canvas app control on a main form |
| Shape | One section with three columns, fixed | One single-column tab with single-column sections | The related table's full main form: tabs, timeline, related rows | The related form's sections, controls and fields | A canvas layout authored in Power Apps Studio |
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.
- Quick create forms streamline creation without leaving the current task
When users need to create a row from a lookup or subgrid, use a quick create form for streamlined data entry. Quick create forms also support creation from the app navigation bar when the table supports that entry point.
Trap Using a quick view form for new-row entry, although it displays related data read-only.
2 questions test this
- You have a model-driven app named App1. While working on an opportunity, users select + New in the Primary Contact lookup to add a contact. They must enter a few contact columns and return to the oppo
- You created and published a quick create form for a custom table named Inspection in a model-driven app named App1. Enable quick create forms is turned on for the table, and Inspection is included in
- Quick create requires table enablement and app inclusion
A table must have Enable quick create forms enabled and be added to the app for its quick create experience to be available. Creating the form definition alone does not complete the configuration.
2 questions test this
- You created a quick create form for a custom table named Asset in a model-driven app named App1. When users select + New in an Asset lookup, the quick create form never appears. You discover that Enab
- A custom table named Asset has Enable quick create forms turned on and a published quick create form. Users of a model-driven app named App1 still can't use the Asset quick create form, and you find t
- Quick create forms have a fixed layout and restricted controls
Quick create forms always have one section with three columns; additional sections or columns cannot be added. They cannot contain subgrids, quick view forms, web resources, iframes, notes, or Bing Maps, so a richer related-data experience requires another form surface.
Trap Using quick create for a multi-section editor with a child-record subgrid, which exceeds its layout and control support.
2 questions test this
- You are editing the quick create form for the Project table in a model-driven app named App1. A manager wants the form to include a subgrid of the project's existing tasks so that users can review the
- A maker wants to redesign the quick create form for the Contact table in a model-driven app named App1 so that it has two sections and four columns, matching the main form. You need to explain the lay
- Quick create form order selects one shared form
Although a table can have multiple quick create forms, form order determines the one used by everyone. Users cannot switch between quick create forms, and these forms cannot be assigned to security roles.
Trap Using role-specific quick create forms for separate departments, although quick create has no role assignment or form switching.
2 questions test this
- You have a model-driven app named App1. The Contact table has a quick create form named Contact Quick A. You create a second quick create form named Contact Quick B, move it to the top of the Quick Cr
- The Lead table in a model-driven app named App1 has two quick create forms named Lead Quick A and Lead Quick B, and form order places Lead Quick A first. User1 prefers Lead Quick B and asks how to swi
- Excluding a quick create form from an app does not reliably suppress it
The Unified Interface runtime can still open a table's existing quick create form from lookups and subgrids even when that form is not included in the app. Microsoft documents deleting the quick create form when its appearance must be prevented, so assess the impact on other apps before removing the shared form asset.
Trap Using the app's form asset selection alone to suppress lookup quick creation, which does not govern this runtime behavior.
2 questions test this
- In a model-driven app named App1, you removed the Contact quick create form from App1's form selection and published the app. Users still see the quick create form when they select + New in Contact lo
- You plan to delete the quick create form for the Contact table so that it stops appearing from lookups in a model-driven app named App1, even though you already excluded it from App1. The Contact tabl
- Quick view forms display a lookup-related row without allowing edits
When users need to read information about a related row while staying on another row's form, add a quick view control bound to the relevant lookup. Its data is read-only, and the control is not visible when the lookup has no value.
Trap Using a card form to show lookup-related details inside another form, although card forms are intended for compact view rows.
2 questions test this
- In a model-driven app named App1, users working on an opportunity must see the phone number and email address of the opportunity's primary contact without navigating to the contact. The information mu
- The Case main form in a model-driven app named App1 includes a quick view control that shows details of the related customer through the Customer lookup. On some new cases, the quick view control does
- Quick view forms have a deliberately limited embedded layout
Quick view forms provide one single-column tab with additional single-column sections, columns, subgrids, and spacers. They do not support form scripts or custom controls; use a form component control when the related-record experience needs richer controls.
Trap Using a scripted quick view form to supply a custom interactive related-record control, which its supported control surface cannot provide.
2 questions test this
- On the Account main form in a model-driven app named App1, users need a related-contact experience that uses a custom Power Apps component framework control to interact with the primary contact's data
- You are editing a quick view form for the Contact table that will be shown through a quick view control on the Account main form in a model-driven app named App1. You want to add more structure to the
When users need the related record's full form, tabs, timeline, or related records without navigating away, open its main form as a dialog. A lookup can be configured to open this modal experience, which can appear at the left, center, or right of the page.
Trap Using a quick view control for editing a related record's timeline and full form, although quick view is read-only.
2 questions test this
- You want users of a model-driven app named App1 to open the full contact main form as a modal overlay when they select the Primary Contact lookup on the Account form, so they stay in the context of th
- From the Account main form in a model-driven app named App1, users must open the primary contact, update its phone number, add a note to the contact's timeline, and create an appointment from the cont
When users should edit a related row within the current form rather than open its complete navigation experience, use a form component control. It embeds the related form's controls and promotes unsaved changes to the hosting main form.
Trap Using a reference panel for inline related-record editing, although reference panels provide read-only related views.
- Card forms provide compact row information in views
Card forms present table rows in a compact format suited to mobile devices. Custom card forms are attached through the legacy Read Only Grid control's Card Form property rather than simply added as standalone app forms; the newer Power Apps grid does not render custom card forms.
Trap Using the Power Apps grid's automatic list reflow as a way to render a custom card form, although that grid does not consume custom card layouts.
2 questions test this
- You created a custom card form for the Account table in a model-driven app named App1, and phone users must see it in the My Active Accounts view. The table currently uses the Power Apps grid control,
- You created a custom card form named Account Mobile Card for the Account table in a model-driven app named App1. In the classic view designer for the My Active Accounts view, you added the Read Only G
- An embedded canvas app brings a custom contextual experience into a model-driven form
When a model-driven form needs a custom visual experience combining its record context with data from additional sources, use an embedded canvas app. The canvas experience appears alongside Dataverse fields on the host form and can receive contextual data from that form.
Trap Using a quick view form for a custom interactive multisource experience, although quick view provides a read-only related-record presentation.
2 questions test this
- You are adding a custom canvas experience to the Contact main form in a model-driven app named App1 by using the form designer. The canvas app must appear on the form next to the Dataverse columns and
- On the Account main form in a model-driven app named App1, users need a custom visual area that combines the current account with sales data from SQL Server and documents from SharePoint, right next t
- ModelDrivenFormIntegration.Item exposes the hosting form's row
In a canvas app created through Customize on the classic form designer's Canvas app control, ModelDrivenFormIntegration.Item is the read-only property for accessing the host form's row. Reference a column through Item to make the embedded experience depend on that row.
2 questions test this
- You created a canvas app by selecting Customize on the Canvas app control of the Account main form in the classic form designer. A label in the canvas app must display the Account Number column, which
- You need a canvas app on the Account main form of a model-driven app named App1 to read the account that is open on the host form by using ModelDrivenFormIntegration.Item. You haven't created the canv
- The integration control's DataSource must remain the unmodified host table
ModelDrivenFormIntegration.DataSource must reference the table of the model-driven form containing the app. Leave this value unfiltered and unmodified so the integration control retains its connection to the correct parent table.
Trap Replacing the integration DataSource with a related child table to drive an embedded gallery, which changes the required host-table binding.
- The host row may not be available when an embedded canvas app starts
ModelDrivenFormIntegration.Item is not guaranteed to contain data at app startup. Gate logic that needs the host row on a readiness check such as !IsBlank(ModelDrivenFormIntegration.Item), rather than relying on startup timing to supply the record.
2 questions test this
- Logic in an embedded canvas app on the Account main form of a model-driven app named App1 needs the host account as soon as the app starts. ModelDrivenFormIntegration.Item isn't guaranteed to be popul
- An embedded canvas app on the Account main form of a model-driven app named App1 reads ModelDrivenFormIntegration.Item.accountnumber in its App.OnStart formula. Sometimes the value is blank when the a
- OnDataRefresh refreshes embedded-app state after the host form saves
ModelDrivenFormIntegration.OnDataRefresh runs its formula when the hosting model-driven form saves data. Use it to refresh the embedded app's data source or update its variables from the host row; Microsoft recommends using this event for refresh work rather than saving embedded-app changes.
2 questions test this
- When users save the host Account main form in a model-driven app named App1, the embedded canvas app must refresh its Accounts data source and set a variable to the current Account Number. You need to
- A maker plans to use ModelDrivenFormIntegration.OnDataRefresh in an embedded canvas app on the Contact main form of a model-driven app named App1 to save changes that users make inside the canvas app
- The integration control's SaveForm action saves the host form
Use ModelDrivenFormIntegration.SaveForm when an embedded canvas interaction needs to save data on the hosting model-driven form. Its target is the host form, not an Edit form inside the canvas app.
Trap Calling SubmitForm on a canvas Edit form to save unsaved host-form fields, which submits the canvas form's own data instead.
- The integration control's RefreshForm action refreshes the host form
ModelDrivenFormIntegration.RefreshForm refreshes data on the hosting model-driven form. Use it when the model-driven surface needs refreshed data, rather than treating a refresh of the embedded app's data source as the same operation.
2 questions test this
- You call ModelDrivenFormIntegration.RefreshForm from an embedded canvas app on the Order main form of a model-driven app named App1. The action requires a parameter named showPrompt with the value tru
- An embedded canvas app on the Account main form of a model-driven app named App1 updates the account's credit limit by using Patch. Afterward, the host Account form still shows the old credit limit un
- Classic embedded canvas binding needs a column guaranteed to contain a value
When adding a Canvas app control to a column in the classic form designer, use a required column guaranteed to contain a value, such as Account Name. If the bound column is empty, the embedded canvas app will not refresh in response to data changes on the host model-driven form.
- The embedded canvas control resolves App name before falling back to App ID
The Canvas app control first looks for the app using its unique name in App name. If no matching app is found, it uses App ID instead. Check these configured identifiers when diagnosing a missing-app reference.
Trap Using the app's display label as App name, which expects the solution-visible unique name.
2 questions test this
- A maker entered Customer Insights, the display name of a canvas app, in the App name field of the Canvas app control on the Account main form, and the App ID value is outdated. The form shows Sorry, w
- The Canvas app control on the Contact main form of a model-driven app named App1 has values in both the App name and App ID fields. You need to explain to a colleague how the control finds the canvas
- An embedded canvas app must exist in the current environment
The canvas app referenced by a model-driven form's Canvas app control must be in the current environment. When troubleshooting an app that cannot be found, verify its presence in the host environment before changing the form's reference.
2 questions test this
- You imported a solution with the Account main form of a model-driven app named App1 into an environment named Test. In Test, the form's Canvas app control shows Sorry, we didn't find that app, althoug
- You are planning environment strategy for a model-driven app named App1 whose Account main form embeds a canvas app by using the Canvas app control. You need to tell the team where the canvas app must
When an embedded canvas interaction should navigate the model-driven host to a particular record's main form, use ModelDrivenFormIntegration.NavigateToMainForm. Supply the table name, main form name, and record ID to identify the destination.
Trap Using canvas Navigate with a screen destination, which changes the canvas screen rather than selecting the host's record and main form.
2 questions test this
- You are writing a formula in an embedded canvas app on the Case main form of a model-driven app named App1 that calls ModelDrivenFormIntegration.NavigateToMainForm to open a related account. You need
- A canvas app embedded on the Account main form of a model-driven app named App1 calls ModelDrivenFormIntegration.NavigateToMainForm when users select a contact in a gallery, so that the host app opens
When an embedded canvas interaction should open a model-driven record list, use ModelDrivenFormIntegration.NavigateToView. Supply the table name and view name to navigate the host to that view.
Trap Using NavigateToMainForm for a record-list destination, which requires an individual record and main form instead of a view.
- OpenQuickCreateForm launches the table's default quick create form
When an embedded canvas interaction should start the host's quick create experience, use ModelDrivenFormIntegration.OpenQuickCreateForm with the table name. The action opens that table's default quick create form.
Trap Using NewForm on a canvas Edit form, which changes the canvas form's mode rather than opening the model-driven quick create form.
2 questions test this
- An embedded canvas app on the Contact main form of a model-driven app named App1 calls ModelDrivenFormIntegration.OpenQuickCreateForm with the entityName parameter set to incident. You need to tell a
- A button in a canvas app that was created from the Canvas app control on the Account main form of a model-driven app named App1 must open the host app's default quick create form for contacts. Users m
- The app designer selects which existing views belong to an app
To tailor a model-driven app's view choices, select its table view page in the app designer and use the Views tab to add or remove views. All views are available by default; selecting specific views narrows the app experience without redesigning the table's public views. Save and publish the app changes.
Trap Changing a public view's filter to remove other view choices, which changes its records rather than the app's component list.
3 questions test this
- You have a model-driven app named App1 that includes the Account table, which has eight public views. App1 users must be able to select only Active Accounts and My Active Accounts, while other apps ke
- You create a model-driven app named App1 and add the Opportunity table by using Add page > Dataverse table. You don't change anything on the Views tab for Opportunity before you save and publish App1.
- You have a model-driven app named App1 that includes the Account table. A public view named Key Accounts appears under Not in this app when you open the Views tab for the Account view page in the app
A personal view is available to its creator unless it is shared with others. Use a personal view for a user's reusable grid configuration instead of changing the administrator-managed system view for everyone.
Trap Editing the shared system view for one user's preferred grid, which changes the common definition rather than creating a private configuration.
2 questions test this
- You have a model-driven app named App1 with modern advanced find turned on. User1 owns a personal view named Budget Watch. User1 shares Budget Watch with a team named Finance and with no one else. Her
- You have a model-driven app named App1. User1 creates a personal view named My Hot Leads by selecting Create view and saving her filters. User1 hasn't shared My Hot Leads with anyone. Her manager asks
- An asterisk identifies view edits that will be lost without saving
An asterisk beside the view name indicates unsaved grid-view changes. Switching views or leaving the page restores the original definition, so save a personal view when the edited configuration must be reused.
3 questions test this
- You have a model-driven app named App1. User1 removes two columns from the Active Accounts view by using Edit columns and selects Apply, and an asterisk appears beside the view name. User1 then leaves
- You have a model-driven app named App1. User1 opens the Active Cases view and drags a column separator to widen the Title column. An asterisk then appears beside the view name. User1 asks you what the
- You have a model-driven app named App1. User1 adds two filter conditions to the My Open Orders view and selects Apply, and an asterisk appears beside the view name. User1 then switches to another view
- Users without Write permission must save an edited view as a new view
When a user changes a system view or a personal view they cannot write, Save as new view preserves their changes as a separate view. Overwriting the existing view requires Write permission, and a distinct name preserves the original definition.
Trap Using Save changes to current view on a shared view with read-only access, which requires Write permission.
2 questions test this
- You have a model-driven app named App1. User1 owns a personal view named My Deals and has Write permission to it. She edits its filters, selects Save as new view, and enters the name My Deals again, e
- You have a model-driven app named App1 with modern advanced find turned on. User2 shared a personal view named Team Pipeline with User1 and granted only Read permission. User1 edits the view's filters
- A user can override the administrator's default view personally
Set current view as my default changes the initial view for that user without changing the administrator's table default. Reset default view returns the user to the administrator-selected default.
Trap Changing the table's default public view to satisfy one user's preference, which alters the shared default.
2 questions test this
- You have a model-driven app named App1. The administrator set My Active Accounts as the default view for the Account table. User1 wants Active Accounts to open by default when she opens Accounts, but
- You have a model-driven app named App1. Last month, User1 selected Active Accounts and chose Set current view as my default, replacing the My Active Accounts default that the administrator set. User1
- Hiding a view affects only the user's selector
With modern advanced find, hiding a view removes it from that user's table view selectors across model-driven apps and devices. Deleting or deactivating a shared personal view affects everyone who uses it. A current default view cannot be hidden until another default is selected.
Trap Deleting a shared personal view to declutter one person's selector, which removes the view for all its users.
2 questions test this
- You have a model-driven app named App1 with modern advanced find turned on. A personal view named Q3 Renewals is shared with User3 and ten colleagues who still use it. User3 no longer needs it and wan
- You have a model-driven app named App1 with modern advanced find turned on. User4 owns a personal view named My Key Accounts and set it as her default view for the Account table. User4 now tries to hi
- Sharing and assigning personal views are different operations
Sharing a personal view grants other users access and requires Share permission. Assigning transfers its ownership to another user or team and is available for views the user owns; it is not necessary merely to let colleagues use the view.
Trap Assigning ownership to distribute a personal view to colleagues, which transfers the owner rather than simply sharing access.
2 questions test this
- You have a model-driven app named App1 with modern advanced find turned on. User6 owns a personal view named Vendor Audit and is moving to another department. A team named Procurement must own Vendor
- You have a model-driven app named App1 with modern advanced find turned on. User5 owns a personal view named Overdue Invoices. Two colleagues must be able to use Overdue Invoices in App1, and User5 mu
- The Power Apps grid is read-only until editing is enabled
The Power Apps grid control supports both read-only and inline-editing experiences. Its Enable editing property defaults to No, so set it to Yes when users should edit records directly in the grid.
2 questions test this
- You are standardizing the grids in a model-driven app named App1. The Account views must stay read-only, while the Opportunity views must allow inline editing. You want a single grid control that supp
- You have a model-driven app named App1. You added the Power Apps grid control to the Contacts subgrid on the Account main form by using the form designer, and you didn't change any of its properties.
- Table-level grid configuration applies across that table's views
Configure the Power Apps grid at table level when all views of the table should use that control. Configure an individual form subgrid when the requirement is limited to the related-record list on that form.
Trap Changing a single form subgrid to update every table view, which changes only that subgrid instance.
2 questions test this
- You have a model-driven app named App1 that uses the Case table. Every view of the Case table must display records by using the Power Apps grid control with inline editing. You need to choose where to
- You have a model-driven app named App1. A colleague added the Power Apps grid control to the Contacts subgrid on the Account main form, set Enable editing to Yes, and expected every Contact view in Ap
- Grid grouping requires infinite scrolling rather than pagination
The grid's Enable pagination setting defaults to No, which provides infinite scrolling. Setting it to Yes provides paging buttons, but column grouping is not supported when pagination is enabled.
Trap Enabling pagination while promising grouped grid rows, which combines incompatible grid capabilities.
2 questions test this
- You manage the Power Apps grid control for the Lead table in a model-driven app named App1. A sales manager asks for paging buttons at the bottom of the Lead views and for the ability to group leads b
- In a model-driven app named App1, the Power Apps grid control for the Opportunity table has Enable grouping set to Yes and Enable pagination set to Yes. Users see paging buttons, but the Group by opti
- Grid grouping is temporary and uses one nonlookup column
When Enable grouping is turned on, users can group rows by one supported column at a time. Lookup columns are not supported, choosing a different grouping replaces the existing grouping, and the grouping is not saved in the view definition.
2 questions test this
- In a model-driven app named App1, the Power Apps grid control for the Account table has Enable grouping set to Yes. A user can group accounts by Industry, but the Group by option doesn't appear in the
- In a model-driven app named App1, grouping is enabled on the Power Apps grid control for the Account table. A user selects Group by on the Region column, and then selects Group by on the Industry colu
- Grid aggregation exposes numeric summaries without creating a chart
Enable aggregation allows users to display sum, minimum, maximum, or average values for numeric columns. The default is No; when enabled alongside grouping, summaries also appear for each group. These runtime aggregations are not saved to the view.
Trap Using Enable grouping alone to expose numeric totals, which requires the separate aggregation setting.
2 questions test this
- In a model-driven app named App1, you set Enable grouping to Yes on the Power Apps grid control for the Opportunity table. Sales managers must see the sum of Est. Revenue for each group directly in th
- In a model-driven app named App1, aggregation and grouping are enabled on the Power Apps grid control for the Invoice table. A user groups invoices by Status and shows the sum of Amount for each group
- Nested grids require both child data and the parent relationship
To expand a grid row into related records, configure Child items with the child table and view, and configure Child items parent ID with the linking relationship column. Child editing inherits the parent grid's editability unless Disable editing in child items grid suppresses it.
2 questions test this
- You are configuring a nested grid in the Power Apps grid control for the Account table in a model-driven app named App1. You set the Child items property to the Contact table and the Active Contacts v
- In a model-driven app named App1, the Power Apps grid control for the Account table has Enable editing set to Yes and a nested grid configured for related contacts. Users must keep editing accounts in
- Reflow behavior controls the grid's small-screen presentation
The grid's Reflow behavior can force Grid only, force List only, or use Reflow to switch according to available width. Reflow is the default, so use it when the same view must adapt between desktop and narrow screens.
Trap Using Enable pagination to obtain a mobile list layout, which changes navigation through rows rather than responsive presentation.
2 questions test this
- In a model-driven app named App1, a colleague set Reflow behavior to Grid only on the Power Apps grid control for the Case table. Agents now see a table on their phones as well as on wide desktop moni
- Field technicians use a model-driven app named App1 on both phones and wide desktop monitors. The Power Apps grid control for the Work Order table must always display records as a list on every device
Navigation types allowed defaults to All. Primary only retains hyperlinks for the primary column while suppressing other lookup links; None suppresses all grid hyperlinks. Use this setting to control navigation opportunities without changing the underlying view columns.
2 questions test this
- In a model-driven app named App1, a kiosk view of the Product table uses the Power Apps grid control. The grid must not render any hyperlinks, including the primary column, but every column in the vie
- In a model-driven app named App1, users of the Case grid must still be able to open a case by selecting its primary column, but the other lookup columns in the grid, such as Customer and Owner, must n
- Main-form security roles determine which layouts users can select
When groups need different forms for the same table, assign Specific security roles in each main form's Form settings. Form order ranks available forms but does not grant form access; Quick Create, Quick View, and Card forms cannot receive role assignments.
Trap Changing form order to restrict a department's form choices, which changes preference rather than eligibility.
2 questions test this
- You are planning role-based forms for the Opportunity table in a model-driven app named App1. Opportunity has a main form, a quick create form, a quick view form, and a card form. You need to identify
- You have a model-driven app named App1. A colleague moved the Case Manager main form to the bottom of the Case form order so that service reps would stop using it. Service reps can still select Case M
- A fallback main form serves users without an explicitly assigned form
For role-based main-form configurations, designate a fallback form so users without a matching form assignment still have a usable interface. A minimally populated contingency form or a generic common form can serve this purpose. Fallback configuration does not apply to quick create, quick view, or card forms.
Trap Using a quick view form as the fallback editor, although fallback is a main-form setting.
2 questions test this
- You use role-based main forms for the Contract table in a model-driven app named App1 to restrict the information people can view or edit. Users whose roles aren't associated with any Contract form mu
- You have a model-driven app named App1. The Account table has three main forms, each assigned to specific security roles. A new employee whose security roles aren't assigned to any Account form must s
- A user's form selection persists after the initial form-order choice
Form order chooses the initial default among available forms. When a user selects another eligible form through the form selector, that selection remains their default until they select a different form, so changing order is not equivalent to resetting every user's preference.
2 questions test this
- In a model-driven app named App1, the Account Sales main form is assigned to the Sales role and ranked first in the Account form order, and the generic Account Common form is the fallback form for eve
- You have a model-driven app named App1. You move a new main form named Case Triage to the top of the Case form order and select Save and publish, expecting every user to start on Case Triage. Several
A main form can be made inactive to prevent its use while retaining the form definition. Forms must also be enabled and included in the app to appear in its form selector, so inspect both form state and app inclusion when a form is missing.
Trap Moving an obsolete form to the bottom of form order, which leaves it available to eligible users.
2 questions test this
- You have a model-driven app named App1. A main form named Lead Qualify is active, and its security roles include every App1 user. However, Lead Qualify doesn't appear in the form selector when users o
- You have a model-driven app named App1. The Account table has an obsolete main form named Account Legacy. Users must no longer be able to use Account Legacy, but the form definition must be kept for r
- Role-based public-view filtering requires an environment feature setting
Role-based system-view filtering requires EnableRoleBasedSystemViews to be true and System Administrator membership for its configuration. Configure the applicable view through View settings and Save and Publish; all system views are available to everyone by default.
2 questions test this
- You are a system administrator for a Dataverse environment that hosts a model-driven app named App1. You plan to make the nondefault public view All Leads visible in the view selector only to users wh
- You need to configure role-based access for public views of the Account table in a Dataverse environment that hosts a model-driven app named App1. The EnableRoleBasedSystemViews property is already se
- Only nondefault public views can receive view security-role assignments
Use Specific security roles on a nondefault public view to tailor its availability in the table list view selector. Default public views cannot be assigned security roles, and special-purpose view types are not interchangeable with these configurable public views.
Trap Assigning view roles to the default public view, which is excluded from this access configuration.
2 questions test this
- You plan to filter the Contact table's view selector in a model-driven app named App1 by security role. You open the Views area for the Contact table in a solution and review the available view types.
- You manage view access for the Account table in a model-driven app named App1. My Active Accounts is the table's default public view. You must make My Active Accounts available in the view selector on
- Role-based view filtering is a selector experience rather than a data-security boundary
Role-based view settings filter the table list view selector, but users can still access views through Manage and share views. System and associated views also remain visible in subgrid and associated-grid selectors. Record visibility continues to follow the user's data privileges, independently of which view is selected.
Trap Using view role assignments to make the underlying records confidential, although the feature filters a selector rather than authorizing record access.
2 questions test this
- You have a model-driven app named App1. The records in the Executive Accounts public view must be confidential, so only users who have the Executive role can read them. A colleague suggests assigning
- You manage view access in a model-driven app named App1. You assign the nondefault public view High Value Leads to the Sales Manager role and select Save and Publish. A user without the Sales Manager
- Restoring a view to Everyone can require a new sign-in
Assigning view security roles takes effect after Save and Publish, and enabling EnableRoleBasedSystemViews takes effect immediately. Changing a view from Specific security roles to Everyone can take up to 24 hours, or become effective when the user signs out and back in.
2 questions test this
- You manage view access in a model-driven app named App1. This morning, you changed the View settings of the All Cases public view from Specific security roles to Everyone and selected Save and Publish
- You are planning role-based view access for a model-driven app named App1. You need to identify which change is effective immediately on its own, without a Save and Publish step and without waiting fo
- Adding a Dataverse table page composes its form and view experience
In the model-driven app designer, Add page > Dataverse table brings selected tables into the app's page structure. Use the Pages pane and the selected table's properties to manage its forms, views, and charts rather than treating the table definition alone as a complete app.
3 questions test this
- You are building a model-driven app named App1 in the app designer. App1 is in an unmanaged solution named Solution1. Users of App1 must work with the forms and views of two existing Dataverse tables
- You are composing a model-driven app named App1 in the app designer. You added the Account and Contact tables by using Add page > Dataverse table. You now need to find the part of the Pages pane that
- You have a model-driven app named App1 that includes the Account table, which you added by using Add page > Dataverse table. In the App1 designer, you select the Account view page in the Pages pane. Y
The app designer's Navigation section organizes pages with areas, groups, and subareas. Enable Areas permits additional areas and cannot be disabled while multiple areas remain; Enable collapsible groups separately controls whether groups can expand and collapse.
Trap Using form tabs to reorganize the app's navigation areas, which changes one record form rather than the app navigation.
2 questions test this
- You have a model-driven app named App1. The App1 navigation contains three groups named Customers, Orders, and Reports, and each group contains several subareas. Users want to expand and collapse the
- You have a model-driven app named App1 whose navigation has two areas named Sales and Service. You open the Navigation settings in the app designer and try to turn off Enable Areas, but the setting ca
- Saving an app does not make its changes available to other users
Save preserves model-driven app edits, while Publish makes the changes available to users. The designer preview reflects edits immediately, and Play opens the app in run mode, so a successful preview is not evidence that the changes have been published.
Trap Using Play as a substitute for Publish, although running the app does not publish edits.
3 questions test this
- You are editing a model-driven app named App1 that the finance team uses. You remove two views from the Invoice table and want to see how App1 will appear to users with the change. The finance team mu
- You have a model-driven app named App1. You change the App1 navigation and select Save. To confirm the change, you select Play, and App1 opens in a new browser tab that shows the new navigation. You t
- You are partway through redesigning the navigation of a model-driven app named App1, which is used daily by the service team. You must keep your incomplete navigation changes so that you can continue
- App form selection controls which form assets the app includes
Select a table form in the app designer to see forms under In this app and Not in this app. Add or remove forms there and publish the app to tailor the form set; by default, all forms are selected. This app composition choice complements, rather than replaces, form-role eligibility.
3 questions test this
- You have a model-driven app named App1. In the app designer, you select the Lead form, move two unused Lead forms from In this app to Not in this app, and select Save. Two days later, users report tha
- You have a model-driven app named App1 that includes the Account table. A maker created a new main form named Account Partner for the Account table. In the App1 designer, the Account Partner form appe
- You have a model-driven app named App1 that includes the Contact table. The Contact table has four main forms, and all of them currently appear under In this app. App1 users must be able to use only t
- Model-driven apps can be shared with roles, users, or teams
Use the app's Share pane to grant access to members of selected security roles or to selected users and teams. This is the model-driven app sharing surface; possession of the app URL alone is not the sharing configuration.
Trap Distributing the Web link without granting app access, which supplies an address rather than an authorization.
3 questions test this
- You have a model-driven app named App1. You copy the Web link for App1 from the Details page and post it on a SharePoint site for the support team. Support team members open the link but can't run App
- You have a model-driven app named App1. The Salesperson security role is assigned to 200 users, but only the 15 members of a Dataverse team named Inside Sales may run App1. The team already has the re
- You have a model-driven app named App1. A contractor named User7 has the Salesperson security role, which 300 other users also have. Only User7 must be able to run App1 at this time, and none of the o
- Sharing an app does not automatically authorize its custom-table data
Users need appropriate table privileges in addition to access to a shared model-driven app. If the app opens but custom-table records are unavailable, verify the assigned roles include privileges for those custom tables rather than repeating the app-share operation.
Trap Resending the app invitation to fix missing custom-table data, which does not add table privileges.
3 questions test this
- You are an app maker who doesn't have rights to edit security roles. You built a model-driven app named App1 that uses a custom table named Site Visit, and you plan to share App1 with members of the B
- You have a model-driven app named App1 that uses a custom Dataverse table named Inspection. You shared App1 with a security role named Inspector. Inspector role members can open App1, but they can't w
- You plan to share a model-driven app named App1 with the members of the predefined Basic User security role. App1 uses the Account table, the Contact table, and a custom table named Equipment. Users m
The model-driven app sharer must have administrative privileges for the environment or be a Power Platform administrator. Their security role must have equal or greater privileges than the role they assign to the app and users, so ordinary app use does not imply authority to share it with elevated roles.
4 questions test this
- User2 has the System Customizer security role in a Dataverse environment. User2 tries to share a model-driven app named App1 and assign the System Administrator security role to the app's users. You n
- A maker named User1 built a model-driven app named App1 and wants to share it with the sales team by assigning the Sales Manager security role. User1 isn't a Power Platform administrator. You need to
- Your company wants a small group of makers to share model-driven apps with other users in a Dataverse environment. You need to recommend the Dataverse security roles that app sharers usually have so t
- A maker who needs to share model-driven apps requires the Dataverse System Customizer security role in the environment named Production, which hosts a model-driven app named App1. You need to identify
- A Microsoft 365 account alone does not make someone an environment user
A recipient of a model-driven app must exist as a user in the app's environment and meet the applicable licensing requirements. Check these prerequisites when a correctly shared app still cannot be opened; directory presence alone is insufficient.
3 questions test this
- You shared a model-driven app named App1 with a security role, and you assigned that role to User3, who has a Microsoft 365 account in your organization. User3 still can't open App1, and you find that
- User4 exists as a user in the environment that hosts a model-driven app named App1, has the required security role, and App1 is shared with that role. App1 contains premium components, and User4 can't
- A custom model-driven app named App1 is hosted in the Contoso tenant. A partner user whose home tenant is Fabrikam is an environment user with the correct role and must use App1. You need to identify
- Model-driven app sharing does not automatically email the app link
After sharing a model-driven app, copy the Web link from its Details and distribute it through an appropriate channel. A Mobile QR code is also available; the sharing operation itself does not currently send an email containing the link.
3 questions test this
- You shared a model-driven app named App1 with the Field Service security role from the Share pane. The field technicians report that they didn't receive any email about App1, and they don't know how t
- You shared a model-driven app named App1 with the Warehouse security role and assigned that role to 40 users. Some of the users work at desktop computers, and others use only phones. Your manager asks
- Your team shares both canvas apps and model-driven apps with users. A new team member assumes that both sharing processes notify users by email with a link to the app. You need to correct the assumpti
- An embedded canvas app requires explicit sharing in addition to host access
Share an embedded canvas app explicitly with its intended users or a security group, and ensure they can access the data sources it uses. Access to the hosting model-driven form does not complete this authorization workflow; the Canvas App table privilege alone also does not share the app.
4 questions test this
- You added an embedded canvas app to the Account main form of a model-driven app named App1. Users who can open the Account form report that the embedded canvas area doesn't load for them, although it
- You shared an embedded canvas app on the Case main form of a model-driven app named App1 with a security group. Group members open the form, and the canvas app reports permission problems with Dataver
- You are sharing an embedded canvas app that appears on the Contact main form of a model-driven app named App1. The canvas app must be available to about 2,000 users across several departments, and you
- An embedded canvas app on the Account main form of a model-driven app named App1 is shared with a security group, and members have read privilege for the Canvas App table. The canvas app shows a Share
- Command customization targets a specific table and command bar location
Choose the command bar location that matches the user experience: Main grid for the full-page record list, Main form for the form's top commands, Subgrid view for that table's rows embedded on another table's form, or Associated view for related data opened from the parent form. To customize contact subgrid commands on an account form, edit the contact table's Subgrid view command bar.
Trap Editing the account Main form command bar to change contact subgrid buttons, which targets a different command location and table.
3 questions test this
- The Account main form in a model-driven app named App1 includes a subgrid that lists the account's related contacts. You need to add a new command to the command bar that appears on that contacts subg
- On an account record in a model-driven app named App1, users select the Related tab and then select Contacts to view the contacts related to the account. You need to add a command to the command bar t
- Users of a model-driven app named App1 must see a new Escalate command as one of the quick actions for the Case table when they play the app. You open the Case table's command bar in the command desig
- Modern commanding separates appearance, action, and visibility
A modern command's display settings define its appearance and placement, its action defines what selecting it does, and its visibility defines when it appears. Use Power Fx for action and visibility logic in the command designer when implementing low-code command behavior.
Trap Reaching for hand-edited classic ribbon XML for a low-code Power Fx command, although classic commands do not support Power Fx actions or visibility.
2 questions test this
- You are configuring a new modern command named Approve on the Order main form of a model-driven app named App1 by using the command designer. You need to define what happens when a user selects the Ap
- You are creating a modern command named Send Survey for the Contact main grid in a model-driven app named App1. The command must appear only when the selected contact has an email address, and it must
- Command designer creates commands scoped to the selected app
Modern commands created using the command designer are visible only within the selected model-driven app. Adding the same table to another app does not automatically give that app these commands, so treat their availability as app-specific when composing the experience.
3 questions test this
- A modern command that you created with the command designer appears on the Account main form in a model-driven app named App1. Users of a model-driven app named App2, which also includes Account, must
- A modern command on the Account main form must appear in every model-driven app that contains the Account table, including apps that are created in the future. Commands that you create in the command
- App1, App2, and App3 are model-driven apps that all include the Account table. You need a new Escalate command on the Account main form that appears only in App1, so that it doesn't transfer to App2 o
- Power Fx command access also requires sharing the command component library
Users of Power Fx commands need the command component library shared with them in addition to an appropriate security role. Include that library in the access configuration when making a model-driven app's Power Fx commands available to its intended audience.
2 questions test this
- A model-driven app named App1 includes modern commands that run JavaScript actions and don't use Power Fx, and other modern commands that use Power Fx. You need to describe which security model govern
- A model-driven app named App1 has commands that run JavaScript actions and a modern command named Escalate that uses Power Fx. You share App1 with a new Field Agents security role that has the require
- Self.Selected supplies the record selection for Power Fx commands
Use Self.Selected.Item for a command's single-record context and Self.Selected.AllItems for the selected record set. For selection-count visibility, CountRows(Self.Selected.AllItems) > 1 tests whether multiple records are selected. Item is blank when the command's SelectionMax is not 1, so multi-record logic must use the selected table rather than a single record.
2 questions test this
- You are writing the action formula for a modern command on the Account main form of a model-driven app named App1. The formula Patch(Accounts, X, {'Account Name': "Changed Account name"}) must update
- A modern command on the Opportunity main grid of a model-driven app named App1 allows users to select many rows at once. The command's formula reads Self.Selected.Item.Name, but the value is always bl
- Self.Selected.State lets a command's visibility depend on form mode
Use Self.Selected.State in a modern command's visibility formula when the command should appear only in a particular form mode. For example, Self.Selected.State = FormMode.New identifies the create-form state.
Trap Testing the number of selected records to identify a new form, which measures selection rather than the form's mode.
2 questions test this
- You are configuring a modern command on the Lead main form of a model-driven app named App1. The command must appear only when Self.Selected.State = FormMode.New is true. In the command designer, you
- A modern command named Copy Address on the Account main form of a model-driven app named App1 must be visible only while users are creating a new account. A maker proposes checking whether no records
- Custom pages provide canvas experiences beyond a model-driven form
When a model-driven app needs a low-code canvas experience as a full page, dialog, or app side pane, use a custom page. Author its flexible layout and expressions in Power Apps Studio to create the required experience within the model-driven app.
Trap Using an embedded canvas app for an app-level side pane, even though embedded canvas apps can only be placed on model-driven forms.
3 questions test this
- Your team plans to add several canvas-based experiences to a model-driven app named App1 by using custom pages instead of embedded canvas apps. A designer asks where a custom page can appear within Ap
- You created a custom page for a model-driven app named App1 from the modern app designer. You now need to build the page's flexible layout, add controls, and write expressions that define the page's d
- A model-driven app named App1 needs a low-code canvas experience that opens in the app side pane on the right side of the app, where users can review tasks while they work on any page. A maker suggest
- Custom pages use the containing model-driven app's end-user sharing
Custom pages rely on model-driven app sharing, so individual pages do not need separate sharing with app users. Configure end-user access through the containing model-driven app rather than treating each custom page as a separately shared canvas app.
2 questions test this
- A model-driven app named App1 includes a custom page named Inspection Wizard. App users already reach the page through App1's sharing. A second maker on your team must now be able to edit Inspection W
- A model-driven app named App1 includes a custom page named Site Survey and is shared with the Inspector security role. Inspectors must run Site Survey, and a second maker, who can't currently open Sit
- Generative pages turn requirements into a model-driven app page
Use Add page > Generative page and Describe a page to describe the required experience, behavior, and data. The agent generates React code for the interface and logic; generative pages are supported in model-driven apps rather than canvas apps.
Trap Choosing a canvas-app screen as the host for a generative page, although this page type belongs to model-driven apps.
2 questions test this
- Your team wants an interactive Kanban page that is built by describing it in natural language and letting the app agent generate the React code. A colleague proposes hosting the page in an existing ca
- You are editing a model-driven app named App1 in the app designer, in an environment located in the United States. You need to create a new page by describing its functional requirements and data in n
- An attached image guides page design rather than supplying a runtime asset
Attach a sketch or screenshot when you want the agent to imitate a layout or visual style. To display a particular image in the finished page, provide an accessible image through Dataverse, a public URL, or a web resource instead of relying on the design attachment.
Trap Treating an attached wireframe image as an automatically hosted runtime image, which confuses design guidance with page data.
2 questions test this
- You are creating a generative page for a model-driven app named App1. Before you select Generate page, you select Add data > Attach image and upload a photo of a rough napkin sketch that shows three p
- You created a generative page in a model-driven app named App1 and attached a wireframe that includes your company logo to the prompt. The generated page imitates the wireframe layout but doesn't disp
- Generative pages can be refined conversationally or through code edits
After generation, refine the page by chatting with the agent or editing the Code tab. Saving a manual code edit creates a new iteration, while Compare becomes available from the second iteration in the current session to inspect changes.
2 questions test this
- You generated a page in a model-driven app named App1. You select Edit on the Code tab and manually change the layout code of the page. You must keep the manual changes as a new iteration of the page,
- Yesterday, you generated and refined a generative page in a model-driven app named App1. Today, you open the page in the designer and complete one new iteration by chatting with the app agent. The Com
- The maker must validate generated page behavior and accessibility
Generated code is a best-effort result, not a guarantee of compliance or correctness. Review and test it before publishing; the Accessibility assistant scans after generation and can pass violations to the agent through Auto fix, but the maker remains responsible for validating the result.
Trap Treating a successful generation preview as a compliance approval, although generation does not validate organizational requirements.
2 questions test this
- You generated a page for a model-driven app named App1 by using the app agent. After you selected Auto fix, the Accessibility assistant reports no remaining violations. Before publishing, a compliance
- You are iterating on a generative page in a model-driven app named App1. After the latest iteration, the Accessibility assistant at the bottom of the screen reports several accessibility violations in
- Existing generative pages are filtered to published pages by default
The Add page > Generative page dialog can reuse existing generative pages in the environment. Its default Published filter can hide an unpublished page; switch to All when locating one. Save preserves work, while Save and Publish publishes the app's pending changes, including generative pages.
2 questions test this
- A colleague created a generative page named Order Board in your environment but hasn't published it yet. You want to add Order Board to a model-driven app named App1. You select Add page > Generative
- A published generative page named Order Board is used in App1, a model-driven app in your environment. App2, another model-driven app in the same environment, must use the same Order Board page withou
- Generative pages can receive record and custom input context
Generative pages accept recordId, entityName, and data inputs when configured to receive them. Describe the expected inputs and how the page should use them in the prompt so the agent generates initialization logic for the contextual experience.
2 questions test this
- You are creating a generative page in a model-driven app named App1. When the page is opened, the calling page must pass a custom filter object, and the page must use the object to filter the records
- You are creating a generative page named Account Insights in a model-driven app named App1. When another page navigates to Account Insights, it must load and display the details of the account that wa
- An embedded generative page receives the current form record ID automatically
To embed a record-aware page in a form, first publish a generative page that accepts recordId, then add the Generative page component from the form designer's Display group. The host form passes its current record ID automatically; additional static inputs can be configured separately.
Trap Hard-coding the current record's ID as a static page input, which binds the experience to one record instead of using the host's runtime context.
2 questions test this
- You published a generative page named Account Health that accepts the recordId input parameter, and you are embedding it in the Account main form of a model-driven app named App1. A colleague suggests
- You published a generative page named Case Timeline that accepts the recordId input parameter. You need to add Case Timeline to a tab of the Case main form in a model-driven app named App1 so that it
- Browser-based generative-page authoring has regional and language constraints
The documented in-browser authoring experience requires an environment in the United States, Great Britain, Australia, or Singapore and supports US English prompting. AI code generation tools provide a separate worldwide public-cloud authoring route, so distinguish the browser experience from that alternative when checking availability.
2 questions test this
- Your Power Platform environment is located in the Great Britain region, and makers in your organization will create generative pages for a model-driven app named App1 by using the in-browser experienc
- Your organization's Power Platform environment is located in Canada. A maker reports that generative pages aren't available when she edits a model-driven app named App1 at make.powerapps.com. The make
- Connector-backed generative pages require a prepared connection reference
Power Platform connector support in generative pages is a preview feature. Prepare an authenticated connection and its connection reference, then select the reference through Add data > Connectors and describe how the page should use it. Selecting a connector name alone does not supply the authenticated connection.
2 questions test this
- You are creating a generative page in a model-driven app named App1 that must display tasks from a Power Platform connector, which is a preview capability. Before you can select the connector data in
- You prepared an authenticated connection and a connection reference for a Power Platform connector. You are now describing a generative page in a model-driven app named App1 that must show data from t
- A custom API lets a generative page invoke a named server operation
With preview custom API support, add an existing Dataverse custom API when a page needs to invoke a named operation at a specific time. Describe its trigger, input values, and response handling in the prompt. Ordinary plug-ins triggered by the page's row operations already run without being added as custom APIs.
Trap Adding every row-update plug-in as a page custom API, although those plug-ins already execute for their registered data operations.
2 questions test this
- A generative page in a model-driven app named App1 updates Order rows. A Dataverse plug-in registered on the Order update operation recalculates totals whenever an order changes. A colleague wants to
- A generative page in a model-driven app named App1 needs an Approve button. When a user selects it, the page must call a named server-side operation that is implemented by a Dataverse plug-in, pass th
- Page localization requires explicit language and formatting instructions
For a multilingual generative page, request translated user-visible text, appropriate right-to-left layout, and dates, numbers, and currency formatted from the user's Dataverse preferences. The page's sitemap entry is not localized automatically and must be handled separately in the app designer.
Trap Translating only the sitemap label to localize the generated interface, which leaves the page's labels and formatting unchanged.
2 questions test this
- You need a generative page in a model-driven app named App1 to support English and Arabic users. A colleague translated the page's sitemap entry in the app designer and expects the page itself to be l
- You are writing the prompt for a multilingual generative page in a model-driven app named App1. Users in several countries will use the page, and dates, numbers, and currency must appear in each user'
- Generative-page editing does not support simultaneous collaboration
Only one maker should work on a generative page at a time because collaborative editing is not supported. Coordinate page edits to avoid unintended conflicts rather than relying on the designer to merge simultaneous work.
2 questions test this
- Two makers on your team must both make changes to the same generative page in a model-driven app named App1 this week. They plan to open the page in the designer at the same time and expect the design
- Two makers edited the same generative page in a model-driven app named App1 at the same time from different browsers. Afterward, some changes made by one of the makers are missing, and the page behave
- Browser-authored generative pages can link up to six Dataverse tables
In the browser generative-page designer, use Add data > Add table to select the Dataverse tables the page should use. A single page can link up to six tables, so keep its data requirements within that supported selection.
- A browser generative-page prompt is limited to 50,000 characters
The browser generative-page authoring experience accepts a prompt of at most 50,000 characters. Keep the page requirements within this character limit when preparing the description.
- System charts are organization-owned rather than individually shared
System charts are available to app users who can read the relevant data. They cannot be assigned or shared with particular users, so do not use system-chart ownership as an audience-selection mechanism.
Trap Sharing a system chart as though it were a personal view, although system charts are organization-owned assets.
2 questions test this
- You created and published a system chart named Pipeline by Stage for the Opportunity table in a model-driven app named App1. A sales director wants only User1 and User2 to receive the chart, so she as
- You published a new system chart named Cases by Priority for the Case table, and the chart is included in a model-driven app named App1. A support manager asks which App1 users can use the chart, beca
- Chart series measure values while categories group them
Choose a series column and aggregation for the quantity to measure, and a category column for the grouping. Sum measures a total, Count measures record quantity, and Average measures the mean; choose the aggregation to match the business question rather than merely the chart shape.
Trap Using Count of revenue to show total revenue, which counts entries rather than summing their amounts.
2 questions test this
- A sales manager wants a system chart in a model-driven app named App1 that shows the average deal size for each salesperson. The Opportunity table has an Est. Revenue currency column and an Owner colu
- You are creating a system chart for the Opportunity table in a model-driven app named App1. The chart must show the total estimated revenue for each industry. A colleague configures Count of Est. Reve
- Nonnumeric chart series support counts rather than arithmetic aggregates
For a nonnumeric series column, the chart designer supports Count: All and Count: Non-empty. Numeric columns also support Average, Max, Min, and Sum; choose Count: Non-empty when missing values must be excluded from the count.
2 questions test this
- A system chart for the Contact table in a model-driven app named App1 must show, for each city, how many contacts have an email address. Contacts whose Email column is empty must not be counted. You s
- You are creating a system chart for the Case table in a model-driven app named App1. You select Status Reason, which is a choice column, in the Column dropdown list of the chart designer, and then you
- Chart averages exclude nulls but include zero values
Minimum, maximum, and average chart calculations exclude NULL values but include zero. Distinguish a missing value from an actual zero when interpreting these aggregates, because the two do not have the same effect on the result.
2 questions test this
- A group in a system chart contains three opportunity records. Their Discount values are 100, 0, and an empty value. The chart uses Average of Discount as the series aggregation. A manager asks what va
- A system chart in a model-driven app named App1 shows the average of the Discount column for each region. Some records have no value in Discount, and other records have a Discount value of 0. A manage
- Top and Bottom chart rules rank aggregated results
Configure Top or Bottom and a count to show only the highest or lowest results according to the selected aggregation. A Bottom rule on Sum of revenue selects the lowest total-revenue groups rather than the individual records with the smallest raw amounts.
Trap Interpreting Bottom on aggregated revenue as a filter on the smallest individual transaction, which ranks a different level of data.
2 questions test this
- A system chart in a model-driven app named App1 shows Sum of Est. Revenue by Account, with Set minimum and maximum values configured as Top and a Count of 3. A sales director wants the chart to rank a
- A system chart for the Opportunity table in a model-driven app named App1 uses Owner as the category and a Count: All aggregation. In the chart designer, you select Set minimum and maximum values, sel
- Stacked charts and comparison charts have different configuration constraints
Stacked and 100% Stacked options are available for bar, column, and area charts. A comparison chart can use up to two category items with one series item, so choose the supported layout according to whether the requirement is stacked measures or multiple grouping categories.
Trap Selecting a pie chart for stacked series, although stacking is supported on bar, column, and area charts.
2 questions test this
- A system chart in a model-driven app named App1 must show revenue for each quarter, with each quarter's bar split into stacked segments for each product line. A colleague suggests using a pie chart wi
- You are building a comparison chart for the Lead table in a model-driven app named App1 by using Add a category in the chart designer. A manager wants to group leads by several columns at once. You ne
- A newly published chart may still need to be added to the app
When an app uses selected charts rather than All charts, a new system chart must be selected in the app designer before users can choose it. Add it through the table view's Charts tab, then save and publish the app.
Trap Recreating a published chart that is missing from one app, when that app's selected chart list excludes it.
2 questions test this
- You published a new system chart for the Opportunity table. Users of a model-driven app named App1 don't see the chart in the chart list, although users of another app can select it. App1 was configur
- App1 is configured with specific charts for the Opportunity table, and App2 is configured to display All charts for the Opportunity table. You publish a new system chart for Opportunity. You need to d
- A chart's preview view does not permanently determine its record set
Selecting a view to preview a model-driven chart does not permanently associate that view with the chart. The chart can display data from another selected view at runtime, so interpret its values in the context of the view currently supplying the records.
2 questions test this
- Yesterday, you previewed a draft system chart for the Case table by using the My Active Cases view in the chart designer. Today, you open the same chart again in the chart designer for a model-driven
- While creating a system chart for the Opportunity table, you previewed it with the My Open Opportunities view. In a model-driven app named App1, users later display the chart with the All Opportunitie
- An oversized chart input requires fewer qualifying records
Model-driven charts support views returning up to 50,000 records. If the chart reports that the maximum record limit is exceeded, reduce the qualifying record set so the view falls within the supported volume.
Trap Changing a column chart to a pie chart to resolve the record-limit error, which leaves the oversized input view unchanged.
2 questions test this
- A column chart for the Activity table in a model-driven app named App1 displays the message The maximum record limit is exceeded. Reduce the number of records. The view that supplies the chart returns
- You are designing views for system charts in a model-driven app named App1. A reporting lead asks how many records a view can return and still be displayed by a chart before the chart shows the maximu
- Users can choose a personal dashboard instead of the system default
An app user can create a user dashboard initially visible only to them, while administrators or customizers create system dashboards for app use. A user can make their own dashboard the default, overriding the system dashboard for their experience.
Trap Replacing the system dashboard to accommodate a single user's default, which changes the shared dashboard rather than the personal selection.
2 questions test this
- In a model-driven app named App1, the system dashboard named Sales Overview opens by default for every user. User1 created a user dashboard named My Pipeline and wants it to open by default for her. A
- User2 creates a user dashboard named Team Escalations in a model-driven app named App1, in an app area where she has privileges. She hasn't shared Team Escalations or asked an administrator to customi
- Standard dashboards combine up to six components
A standard model-driven dashboard can include up to six components, such as charts and lists. When adding a chart component, select its Record Type, View, and Chart so both the visualization and the record subset are defined.
2 questions test this
- You are adding a chart to a tile of a standard system dashboard for a model-driven app named App1. The chart must show open opportunities grouped by sales stage. You select the chart icon on the tile,
- You are creating a standard system dashboard named Operations Summary for a model-driven app named App1 by using the 3-column overview layout. The operations manager wants as many charts and lists as
- Interactive dashboards support acting directly on workload records
Use an interactive dashboard when users need to review real-time work streams and act on records without navigating through the app. A standard dashboard primarily combines components such as charts and lists, whereas interactive dashboards provide this workload-oriented experience.
Trap Choosing a standard dashboard solely to satisfy interactive work-stream processing, which is the purpose of an interactive dashboard.
2 questions test this
- Service managers use a standard system dashboard in a model-driven app named App1 that shows case charts and a list of active cases. To work on a case, reps currently open it from the list. You propos
- Service reps who use a model-driven app named App1 need a one-stop workplace where they see their workload in real time across several streams and act on cases directly, without paging through the app
- Multi-stream dashboards can combine separate table-specific streams
Each interactive dashboard stream is based on one table, but a general multi-stream dashboard can contain streams from different tables. A table-specific dashboard instead bases its streams on that table; a single-stream dashboard presents one stream based on a view or queue.
Trap Combining records from unrelated tables inside one stream, although each stream has a single table basis.
2 questions test this
- A home page interactive dashboard in a model-driven app named App1 must show active cases and open tasks at the same time. A colleague proposes building one stream that contains both the Case rows and
- You create an interactive dashboard from the Dashboards area of the Case table in a model-driven app named App1. The Filter Table is preset to Case. A supervisor asks whether one of the dashboard's st
- Interactive dashboard filters have explicit table and time-column scope
Interactive charts act as visual filters. The Filter Table defines the global-filter attributes and related stream or tile scope, while Filter By selects the date column used by the timeframe filter and Time Frame sets its default interval.
Trap Changing Time Frame to switch the date column being filtered, which requires changing Filter By instead.
2 questions test this
- You are configuring a multi-stream interactive dashboard for a model-driven app named App1. The global filter must work on all charts and also on the streams and tiles that are based on the Case table
- An interactive dashboard in a model-driven app named App1 has Filter Table set to Case, Filter By set to Created On, and Time Frame set to This Month. Users must filter cases by the Resolved On column
- Queue-backed dashboard streams require queue-enabled tables
A dashboard stream can use a view or a queue only when the underlying table supports the chosen source. If a table is not queue enabled, the Queue option is unavailable and the stream must use a view.
2 questions test this
- You are adding a stream to an interactive dashboard for a custom table named Inspection in a model-driven app named App1. When the stream dialog opens, only the View option is visible, and the Queue o
- The Case table in your environment is queue enabled. You are adding a stream to a multi-stream interactive dashboard for Case in a model-driven app named App1, and the stream dialog asks you to choose
- Interactive dashboard audiences can be restricted by security role
Use Enable security roles on an interactive dashboard and Display only to these selected security roles to target its audience. Publish the dashboard after changing this configuration so the intended role-based experience is available.
2 questions test this
- You selected Enable security roles for an interactive dashboard in a model-driven app named App1, chose Display only to these selected security roles, selected the Service Manager role, and selected O
- An interactive dashboard named Escalation Center in a model-driven app named App1 must be available only to users who have the Service Manager security role. Other users of App1 must not see Escalatio
- Individual Power BI tiles can be added to personal dashboards
To mix a Power BI tile with other dashboard components, add the tile to a personal model-driven dashboard. The organization must allow Power BI visualizations, and the user needs a Power BI account and access to the source dashboard; third-party cookies are required for the documented browser authentication flow.
Trap Using a standard system dashboard tile slot as the personal Power BI Tile insertion surface, which is not that integration workflow.
2 questions test this
- User1 of a model-driven app named App1 wants a Power BI tile from her Power BI workspace to appear next to two Dataverse charts on one dashboard in App1. Power BI visualizations are enabled for the or
- Power BI visualizations are enabled for your organization, and User2 has a Power BI account with access to a Power BI dashboard. When User2 selects Power BI Tile on her personal dashboard in a model-d
- A shared dashboard does not automatically share its Power BI content
Sharing a personal dashboard containing Power BI visualizations requires sharing in both Dataverse and Power BI. Recipients need appropriate access in both services, so a visible dashboard shell does not prove they can read the embedded visualizations.
Trap Sharing only the Dataverse dashboard to grant access to embedded Power BI content, which remains protected by Power BI authorization.
2 questions test this
- Before User4 shares a personal dashboard that contains Power BI visualizations from a model-driven app named App1 with a security group, her manager asks what the recipients need so that both the dash
- User3 shared her personal dashboard, which contains Power BI tiles, with two colleagues by selecting SHARE DASHBOARD in a model-driven app named App1. The colleagues can open the dashboard and see its
- A Power BI embedded system dashboard can reference a report or dashboard
Use New > Dashboard > Power BI embedded to create a system dashboard referencing a Power BI report or dashboard and its workspace. Add it to the model-driven app through Add page > Dashboard and the Power BI dashboards picker. Users still need the applicable Power BI authorization and license.
Trap Choosing a personal Power BI tile when the requirement is an app-wide system dashboard referencing a whole report.
2 questions test this
- All users of a model-driven app named App1 must be able to open the complete Sales Performance Power BI report from a dashboard in the app navigation. Each user has a Power BI license and access to th
- You created a Power BI embedded system dashboard named Regional Sales in a solution. You now need to add Regional Sales to a model-driven app named App1 so that users can select it from the app's left
- System-dashboard Power BI embedding ignores the personal-visualization setting
Power BI content embedded in a system dashboard or form is not controlled by the environment's Power BI visualization embedding setting. That setting governs end users adding Power BI visualizations to personal experiences, so disabling it does not disable system-dashboard embedding.
References
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/model-driven-app-overview
- https://learn.microsoft.com/en-us/power-apps/user/grid-filters-advanced
- https://learn.microsoft.com/en-us/credentials/certifications/resources/study-guides/ab-410
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/app-designer-overview
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-add-remove-forms-views-dashboards
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/design-productive-forms
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/share-model-driven-app
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/the-power-apps-grid-control
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-edit-quick-create-forms
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/configure-event-handlers-legacy
- https://learn.microsoft.com/en-us/power-apps/maker/data-platform/data-platform-create-business-rule
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-edit-quick-view-forms
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/embedded-canvas-app-add-classic-designer
- https://learn.microsoft.com/en-us/power-platform/alm/solution-concepts-alm
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/embedded-canvas-app-properties-actions
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/embedded-canvas-app-actions
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/manage-view-access
- https://learn.microsoft.com/en-us/power-apps/user/grid-filters
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/command-designer-overview
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/commanding-use-powerfx
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/model-app-page-overview
- https://learn.microsoft.com/en-us/power-apps/developer/model-driven-apps/clientapi/understand-clientapi-object-model
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/generative-pages
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-edit-system-chart
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-edit-dashboards
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/configure-interactive-experience-dashboards
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-edit-powerbi-embedded-page
- https://learn.microsoft.com/en-us/power-apps/user/add-powerbi-dashboards
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/control-access-forms
- https://learn.microsoft.com/en-us/power-platform/admin/wp-security-cds
- https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/share-embedded-canvas-app