Domain 2 of 3 · Chapter 1 of 2

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.

Model-driven appArea: SalesGroup: CustomersGroup: InsightsSubareaAccountsSubareaContactsSubareaDashboardsEach subarea leads to a page
Model-driven app navigation in three levels: an area holds groups, and each group holds the subareas users select to open pages.

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.

Hostmodel-drivenformEmbeddedcanvas appItem (host row)OnDataRefreshSaveFormRefreshFormHost navigation
The ModelDrivenFormIntegration control in both directions: properties carry the host row to the embedded canvas app, actions carry requests back to the host form.

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

  1. 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.
  2. Describe the page: its functional requirements and any user experience specifications. A prompt can be at most 50,000 characters.
  3. 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).
  4. Optionally attach an image, anything from a napkin sketch to a high-resolution mockup, to guide the layout or visual style.
  5. Select Generate page. The agent outlines its interpretation and plan, writes the code, transpiles it and renders the result.
  6. 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.
  7. 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.

Describe the pageAdd data: up to six tablesGenerate pageRefine: chat or Code tabValidate, Save and Publish
In-browser generative page workflow in Power Apps, from the description to Save and Publish, with refinement looping back to generation.

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 ApproveOrder API, 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.

DashboardStandardcharts, listsInteractiveact on recordsMulti-streammany streamsSingle-streamone streamHome pageTable-specific
Kinds of model-driven dashboards by interactivity: standard versus interactive, then multi-stream versus single-stream, then home page versus table-specific.

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.

  1. 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]).
  2. App inclusion: does this app contain the component? This is set in the app designer (see Composing the app in the app designer).
  3. 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.
  4. 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.

Access problem1. App sharingmay they open the app?2. App inclusiondoes the app contain it?3. Role targetingis it offered to their role?4. Data privilegeswhich records? (secures data)
Four questions for diagnosing access to a model-driven app, in diagnostic order: three decide what is offered; only data privileges secure records.

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.

Active main formsincluded in the appKeep forms assignedto the user's rolesAny form left?NoFallbackformYesForm order picksthe default formA form the user picksstays their default
How a user's main form is chosen: app inclusion and active state, then security roles, then the fallback form or the form order, then the user's own selection.

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

RequirementQuick create formQuick view formMain form dialogForm component controlEmbedded canvas app
What the user doesCreates a new row quicklyReads a related rowWorks with the whole related recordEdits a related row inlineUses a custom experience combining several data sources
Edits data?Yes, the new rowNo, read-onlyYes, on the related row's main formYes; unsaved changes are promoted to the host main formIf created from the classic form designer: reads the host row; its SaveForm action saves the host form
Opened fromCreate button, or + New on a lookup or subgridA quick view control bound to a lookup on the formA lookup configured to open the related main form as a dialogThe host main form, where it is embeddedThe Canvas app control on a main form
ShapeOne section with three columns, fixedOne single-column tab with single-column sectionsThe related table's full main form: tabs, timeline, related rowsThe related form's sections, controls and fieldsA canvas layout authored in Power Apps Studio

Decision tree

Quick one-sectionnew-row entry?YesQuick createformNoSeveral data sourceson the form?YesEmbeddedcanvas appNoMust edit therelated row?NoQuick viewformYesFull form, timelineor business processflow needed?YesMain formdialogNoForm componentcontrol

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

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

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.

1 question tests this
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
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
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
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.

1 question tests this
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
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
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.

1 question tests this
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
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.

1 question tests this
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
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
NavigateToMainForm opens a specified record in the host's main form experience

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
NavigateToView opens a named view in the model-driven host

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.

1 question tests this
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
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
Personal views are private unless explicitly shared

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

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

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
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
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
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
Deactivating a main form prevents users from selecting it

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
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
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
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
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
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
Areas, groups, and subareas organize model-driven app navigation

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
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
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
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
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
The app sharer needs sufficient authority for the roles being assigned

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

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

1 question tests this

References

  1. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/model-driven-app-overview
  2. https://learn.microsoft.com/en-us/power-apps/user/grid-filters-advanced
  3. https://learn.microsoft.com/en-us/credentials/certifications/resources/study-guides/ab-410
  4. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/app-designer-overview
  5. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-add-remove-forms-views-dashboards
  6. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/design-productive-forms
  7. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/share-model-driven-app
  8. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/the-power-apps-grid-control
  9. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-edit-quick-create-forms
  10. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/configure-event-handlers-legacy
  11. https://learn.microsoft.com/en-us/power-apps/maker/data-platform/data-platform-create-business-rule
  12. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-edit-quick-view-forms
  13. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/embedded-canvas-app-add-classic-designer
  14. https://learn.microsoft.com/en-us/power-platform/alm/solution-concepts-alm
  15. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/embedded-canvas-app-properties-actions
  16. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/embedded-canvas-app-actions
  17. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/manage-view-access
  18. https://learn.microsoft.com/en-us/power-apps/user/grid-filters
  19. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/command-designer-overview
  20. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/commanding-use-powerfx
  21. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/model-app-page-overview
  22. https://learn.microsoft.com/en-us/power-apps/developer/model-driven-apps/clientapi/understand-clientapi-object-model
  23. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/generative-pages
  24. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-edit-system-chart
  25. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-edit-dashboards
  26. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/configure-interactive-experience-dashboards
  27. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/create-edit-powerbi-embedded-page
  28. https://learn.microsoft.com/en-us/power-apps/user/add-powerbi-dashboards
  29. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/control-access-forms
  30. https://learn.microsoft.com/en-us/power-platform/admin/wp-security-cds
  31. https://learn.microsoft.com/en-us/power-apps/maker/model-driven-apps/share-embedded-canvas-app