Study Guide · AB-410

AB-410 Cheat Sheet

633 entries · 7 chapters · 3 domains

Create a foundation for intelligent applications

Design Power Platform solutions with AI-enabled tools

Read full chapter

Cheat sheet

Sharp facts the exam loves — scan these before test day.

Plans turns a business description into a proposed multi-component solution

When requirements span data, applications, and automation, use plans in Power Apps to develop a coordinated solution proposal. Supply the business use case in natural language and optionally add process diagrams, data models, or legacy-app screenshots to give Copilot context.

Trap Using the table-creation Copilot alone as the complete solution planner, although its output focuses on tables and relationships.

3 questions test this
Review user roles and needs before accepting the generated data model

Plans progresses from user requirements to the data model and then the technology proposal. Edit generated roles and needs inline or through Copilot before selecting Looks good, so later recommendations reflect the intended users and their work.

3 questions test this
Technology proposal details identify the requirements and tables each component serves

A proposed technology's information card identifies the user roles it supports and the data tables it uses. Review that mapping when deciding whether to accept the proposal or request changes, rather than evaluating the component name alone.

3 questions test this
Save the plan and tables before creating the proposed solution objects

Save tables establishes the plan in a solution and asks for a solution and publisher, or an existing solution. After this step, create the proposed apps, flows, sites, or agents in their respective authoring experiences; a proposal is not already a published application.

Trap Treating acceptance of the technology proposal as deployment, although object creation and publication still remain.

3 questions test this
Plans can replace a proposed app with an existing app

When an existing app already meets the need, use Replace on the proposed app tile rather than create a duplicate. Add technology includes an additional existing app, but existing apps added to a plan are not automatically included in its new solution.

Trap Assuming an existing app attached to a plan is automatically packaged in the new solution, although its solution membership remains separate.

3 questions test this
Plans requires Dataverse and an eligible environment

Plans requires an environment with a Dataverse database and an eligible locale. If the current environment is unsuitable, eligible makers can be redirected to a developer environment; otherwise they must switch to an environment where they can create tables.

2 questions test this
Plan copresence does not permit simultaneous editing

Plans can show multiple collaborators, but only one author can edit at a time. Later arrivals have read-only access until the editor leaves or becomes inactive, so shared edit permission does not imply concurrent coauthoring.

Trap Choosing copresence for simultaneous edits by several makers, although it provides only one active editing session.

3 questions test this
App-type selection depends on whether the experience or the data model leads the design

When a task needs a highly tailored interface and connections to multiple data sources, choose a canvas app. When the solution centers on Dataverse business data and related processes, choose a model-driven app whose forms and views generate a responsive interface from that model. The choice is about the dominant design requirement, not simply whether the app runs on a phone.

Trap Choosing a canvas app solely for mobile use, although model-driven interfaces also respond to device size.

3 questions test this
Power Pages serves external website audiences using Dataverse

When customers or partners need an external-facing website connected to Dataverse, select Power Pages. It supports sign-in through a variety of identities and anonymous content browsing, allowing the solution to serve an external audience rather than requiring an internal application experience.

2 questions test this
An agent can provide conversation while a flow performs the repeatable process

When users need to express requests conversationally, use an agent as the interaction component; use an app interface when they need direct interaction with screens and data controls. A rule-based workflow remains appropriate for a prescribed sequence of actions. An agent can call an agent flow, so adding conversation does not require replacing the deterministic process with generative decisions.

Trap Replacing a fixed processing sequence with generative decision-making solely because requests arrive through chat.

4 questions test this
Dataflows provide repeatable transformation and loading into Dataverse

When data must be cleaned, transformed, and loaded into Dataverse repeatedly, choose a Power Apps dataflow. Define the preparation steps in Power Query and configure automatic scheduled refresh to rerun them. This loads prepared data into the destination rather than merely previewing an imported file or reading external rows dynamically at runtime.

Trap Choosing a virtual table for a requirement to persist regularly transformed copies in Dataverse, although virtual tables expose external rows at runtime.

3 questions test this
The Requirements Agent translates the business problem into user needs

Use the Requirements Agent's output to establish who the solution serves and what each role needs to accomplish. It is the first planning stage; review its proposed roles and requirements before letting later agents design implementation components.

Trap Reaching for the Data Agent to define user needs, although its responsibility is the proposed data model.

5 questions test this
The Data Agent proposes tables, columns, and relationships

The Data Agent translates the accepted business needs into a proposed data model with tables, column types, and relationships. Its suggestions can be reviewed and edited in the data workspace before the plan proceeds to technology selection.

Trap Using the Solution Agent as the schema-design specialist, although its role is choosing the technologies that consume the data.

5 questions test this
The Solution Agent recommends technologies for the accepted requirements and data

The Solution Agent evaluates the needs, processes, and data to propose apps, flows, and agents. Use it when deciding the combination of implementation components, then review whether each proposed component addresses the business problem.

Trap Using the Requirements Agent to select the final app and flow combination, although it establishes needs rather than the technology proposal.

5 questions test this
Form fill assistance offers suggestions that require explicit acceptance

When users need help entering data while retaining control, evaluate built-in form fill assistance. It suggests values for empty fields from recent usage, smart-pasted text or images, or supplied files; suggestions are not saved unless the user explicitly accepts them.

Trap Choosing form fill assistance for unattended record enrichment, although its suggestions depend on user review and acceptance.

3 questions test this
Form fill assistance can be disabled for individual sensitive columns

The Allow form fill assistance column setting (preview) controls whether a supported column receives AI suggestions. Disable it for sensitive columns while retaining assistance elsewhere; using the feature also requires an enabled AI form fill assistance environment setting.

Trap Using a column security profile solely to suppress AI suggestions, although it governs data access rather than the assistance setting.

3 questions test this
Copilot chat provides conversational data insights where that experience remains supported

Copilot chat for model-driven apps lets users ask natural-language questions about Dataverse data rather than receive form-entry suggestions. This experience depends on Dataverse search, and enabling search alone does not enable every Copilot feature. Evaluate its availability before selecting it: Microsoft documents this as a preview feature in Power Apps, with deprecation beginning January 2026 for environments not enabled for Dynamics 365 apps, and recommends Microsoft Copilot as the replacement there.

Trap Selecting form fill assistance for conversational questions about existing records, although its purpose is proposing field values.

4 questions test this
Copilot selection must account for the business context it can actually access

For questions about organizational information, evaluate the proposed Copilot experience's grounding sources and the user's permissions. Web-grounded chat alone does not establish access to internal business context; that context must be available through a supported organizational-data capability, agent, or explicitly supplied content. Organizational grounding remains scoped by user permissions.

Trap Selecting web-grounded assistance for internal-record questions without providing a supported source of organizational context.

3 questions test this
Custom connectors expose services that lack a suitable prebuilt connector

When the solution must call an API that has no suitable prebuilt connector, recommend a custom connector. It wraps API operations as reusable actions or triggers for Power Platform consumers; a connection is still needed to use the API, with authentication when required by the API.

Trap Selecting a Power Apps component framework control for connector actions when no custom user interface is needed.

3 questions test this
Power Apps component framework extends the application's visual controls

Recommend a Power Apps component framework code component when standard controls cannot provide the required data interaction or visualization. Components can replace a numeric field with a dial or present a dataset as a calendar, and can be reused in supported canvas and model-driven experiences.

Trap Choosing a Dataverse plug-in to render a custom interactive control, although plug-ins execute server-side data-event logic.

3 questions test this
Dataverse plug-ins extend data operations when declarative options are insufficient

Recommend a Dataverse plug-in when a requirement needs custom handling of a Dataverse data event and available declarative options do not meet it. A plug-in can augment or cancel the data operation, but requires developer implementation and maintenance.

Trap Choosing a custom connector to intercept and cancel Dataverse operations, although a connector exposes callable API operations rather than an event-pipeline handler.

3 questions test this
Synchronous extensions delay the data operation while asynchronous extensions run afterward

A synchronous Dataverse plug-in makes the data operation wait for its work, so recommend it only when the operation must depend on the result. Asynchronous execution queues the extension after the operation finishes and is appropriate when the work can occur later.

Trap Selecting an asynchronous plug-in to prevent the original save, although that operation has already finished before the queued work executes.

3 questions test this
Private API integration can require an on-premises data gateway

For an API visible only within a private network, evaluate an on-premises data gateway alongside the custom connector. The connector describes the operations, while the gateway supplies the connectivity path to the private service.

Trap Treating a custom connector definition as a network tunnel, although describing an API does not provide private-network connectivity.

3 questions test this
Azure Functions can host custom APIs exposed through a connector

When a solution needs custom server-side processing outside Dataverse, Azure Functions is an option for hosting the API. A custom connector can expose that API to Power Apps, Power Automate, or Copilot Studio, separating service implementation from low-code consumption.

Trap Treating the custom connector as the API's execution host, although it wraps a service implemented elsewhere.

3 questions test this
Client scripting extends model-driven form interactions beyond available low-code capabilities

When a model-driven form interaction cannot be achieved with supported low-code form capabilities, recommend JavaScript client scripting through the supported client APIs. Scripts can respond to form events such as loading or column changes to control the client experience. This is a client-behavior extension, rather than a request for a replacement visual control or server-side handling of a Dataverse data operation.

Trap Choosing a Dataverse plug-in to react directly to a form-load interaction, although plug-ins handle server-side data events.

2 questions test this
Production environments are intended for permanent operational workloads

Use a production environment for business workloads on which the organization depends. Keep development and testing separate so experiments and validation do not modify the operational application and data.

Trap Selecting the default environment as the standard production location, although it is intended for exploration and lightweight experimentation.

2 questions test this
Sandbox environments provide copy and reset capabilities for nonproduction work

Choose a sandbox when development or testing needs an isolated environment that can be copied or reset. Its purpose is nonproduction validation rather than permanent business operation.

Trap Choosing a production environment for disposable reset-based testing, although sandbox is the type designed for those operations.

3 questions test this
Trial environments expire and suit short-term evaluation

A standard trial environment expires after 30 days and is intended for short-term testing. Choose a permanent environment type when the solution must continue operating beyond the evaluation period.

Trap Using a trial environment for a permanent departmental service, although the environment has an expiration lifecycle.

2 questions test this
The default environment is tenant-wide and unsuitable as a protected production boundary

Each tenant automatically receives one default environment, and licensed users receive Environment Maker access there. Its exploration-oriented purpose and lack of backup guarantees make it unsuitable for production workloads; it cannot be deleted.

Trap Choosing the default environment to isolate a restricted department's makers, although its maker population is tenant-wide.

4 questions test this
Developer environments are for individual development rather than shared production

Developer environments are intended for the owner's development work, and security groups cannot be assigned to them. Recommend a production or sandbox environment when the requirement is a centrally controlled operational or shared testing environment.

Trap Selecting a developer environment for security-group-controlled production access, although that environment type does not support assigning security groups.

4 questions test this
An environment contains at most one Dataverse database

A Power Platform environment can have zero or one Dataverse database. When a solution needs independently isolated Dataverse databases for development and production, place them in separate environments rather than attempting to add a second database to one environment.

Trap Adding a second Dataverse database inside the existing environment for production isolation, although the environment supports only one.

3 questions test this
An environment's location determines the geographic placement of its resources

When a solution requires a particular geographic placement, select an environment in the appropriate location because the environment and the resources created in it are bound to that geography. Apps created there are routed to datacenters in that macro region. For production and sandbox environments, the location is selected at creation time.

3 questions test this
Develop unmanaged solutions and distribute managed build artifacts

Use an unmanaged solution as the editable source in development, and export it as managed for downstream test and production environments. Keep the unmanaged source in source control; an installed managed solution cannot itself be exported as the development source.

Trap Distributing an unmanaged solution as the third-party product artifact, although it becomes editable customizations rather than a separately serviceable managed package.

3 questions test this
Deleting a solution has different effects for managed and unmanaged packages

Deleting an unmanaged solution removes its container but leaves its customizations in the default solution. Uninstalling a managed solution removes its included customizations and can delete data in its custom tables and custom columns, so assess those effects before removal.

Trap Using managed-solution uninstall as a harmless container cleanup, although it removes included assets and their stored data.

3 questions test this
Choose the custom publisher prefix before creating schema components

The solution publisher's prefix identifies new metadata components and reduces naming collisions. Create or select the appropriate custom publisher before creating tables and columns, because changing the publisher prefix later does not rename existing schema items.

Trap Changing the publisher prefix after creating a column to rename its schema, although existing metadata names are immutable.

2 questions test this
Managed component ownership cannot be moved between publishers

A component's creating solution publisher owns that component. Ownership can move between solutions of the same publisher, but not across publishers after introduction in a managed solution, so choose publisher boundaries before distributing the product.

Trap Moving an existing managed component to a newly named publisher to transfer ownership, although ownership transfer is limited to solutions within the same publisher.

3 questions test this
Solution dependencies determine installation and removal order

Install a required base solution before installing a dependent solution. Removal reverses that order: dependent solutions or customizations must be removed before the base can be uninstalled. Use dependency information to identify what requires a component before deleting it.

Trap Inspecting managed properties to find every dependent component, although those properties control customizability rather than dependency relationships.

3 questions test this
Managed properties determine which distributed components remain customizable

Before extending a managed component, inspect its managed properties. If customization is permitted, add it to an unmanaged solution and customize there; the change creates an unmanaged dependency on the installed managed solution.

Trap Editing the component directly inside the managed solution, although permitted customizations must be made through an unmanaged solution.

3 questions test this
Test a managed export in an environment separate from its unmanaged source

A managed solution cannot be imported into the environment that contains its originating unmanaged solution. Use a separate test environment to validate the managed installation and dependency behavior before production deployment.

Trap Importing the managed export back into the source environment to test installation, although the originating unmanaged solution prevents that import.

3 questions test this
A preferred unmanaged solution captures supported work outside explicit solution context

Set a custom unmanaged solution as the preferred solution when supported components created outside an explicit solution context should enter your deployment package automatically. The preference is not universal: components created in classic solution explorer do not enter it, and other authoring surfaces have documented limitations. Verify package membership rather than treating the preference as a guarantee for every component.

Trap Relying on the preferred solution to capture classic solution explorer creations, although that surface does not honor the preference.

3 questions test this
The system Default Solution is not an exportable deployment package

The system solution named Default Solution cannot be exported for import into another environment. Put the components to distribute in a custom solution instead of relying on their visibility in the system-wide Default Solution.

3 questions test this
Segment existing tables to ship only the assets that changed

When a table already exists in the target environment, use table segmentation to include the changed table assets and required dependencies rather than all unrelated components. Use Edit objects to select the needed columns, forms, or views. This reduces unnecessary solution layers and dependencies.

Trap Selecting Include all objects for a single-column change on an existing target table, introducing unrelated assets and layers.

3 questions test this
A table absent from the target requires Include all objects

When a table does not yet exist in the target environment, select Include all objects when adding it to the solution. Segmenting that new table can omit parts of its definition and produce missing-dependency errors during import.

Trap Applying existing-table segmentation to a first-time table deployment, leaving the target without required components.

3 questions test this
Removing a component from a solution preserves it in the environment

Use Remove from this solution when an object should leave an unmanaged package but remain available in the environment. Delete from this environment is the destructive alternative: it removes the object and can remove associated data, such as rows stored in a deleted custom table.

Trap Choosing Delete from this environment to exclude a component from one release package, removing the underlying object instead of only its membership.

2 questions test this
Use a solution upgrade when obsolete components must be removed

A managed solution update adds or modifies components but does not delete omitted components. An upgrade removes components no longer included and can roll patches into a new base, so use an upgrade when the release retires an asset.

Trap Importing an update to remove an omitted column, although updates leave components that are absent from the new package.

3 questions test this
A solution patch contains changes to a parent and cannot delete components

A patch packages additions or modifications for a parent managed solution and is layered above that parent. It cannot remove components; Microsoft currently recommends avoiding patch-based servicing in favor of a simpler solution lifecycle where possible.

Trap Selecting a patch to uninstall one obsolete component, although patches only add or modify parent-solution assets.

3 questions test this
All unmanaged customizations share one active unmanaged layer

Imported unmanaged solutions and ad-hoc customizations share a single unmanaged layer rather than separate independently removable layers. Inspect that active layer when a managed deployment appears not to change runtime behavior, because unmanaged customizations can remain above managed definitions.

Trap Deleting one unmanaged solution container to roll back its layer, although unmanaged solutions do not have separate runtime layers.

3 questions test this
Forms, model-driven apps, and site maps merge across solution layers

Model-driven apps, forms, and site maps support merge behavior when layered customizations are combined. Other component types generally use top-layer-wins behavior, so do not expect a canvas app or cloud flow to merge like a form.

Trap Expecting two cloud-flow definitions to merge their actions, although cloud flows use top-layer-wins behavior.

3 questions test this
A staged upgrade can affect runtime before Apply upgrade consolidates the layers

A staged upgrade appears as a pending upgrade layer above the base and patches. For top-layer-wins components, that pending layer can already determine runtime properties; Apply upgrade subsequently consolidates the layers into the new base.

Trap Treating a staged upgrade as entirely inert until Apply upgrade, although its top layer can already determine component behavior.

3 questions test this
Solution checker analyzes static quality rather than guaranteeing target import success

Run solution checker on an exportable unmanaged solution to identify problematic patterns against best-practice rules. Its static analysis does not know the destination environment's configuration or installed dependencies. A clean report therefore complements, rather than replaces, target import validation.

Trap Substituting solution checker's clean report for target dependency validation, although static analysis does not inspect target configuration.

3 questions test this
Object checker diagnoses live metadata and layering problems

When a deployed model-driven app or site map has an ALM-related problem in test or production, use object checker (preview) to analyze its live database metadata and layering. It examines the object regardless of which solutions contain it, unlike solution checker's offline analysis of a single exported solution file.

Trap Using only an exported package's solution checker results to diagnose the deployed object's live layering state.

3 questions test this
Solution history records operation outcomes and failure diagnostics

Use See history in the Solutions area to inspect import, export, and uninstall operations and their results. For a failed operation, open its details and examine the Error code and Exception message; the Activity Id helps correlate the failure with support investigations. A solution's presence in the environment does not establish that its latest operation succeeded.

3 questions test this
Environment variables separate deployable logic from environment-specific parameters

Use environment variables for configuration such as a SharePoint site or list that differs between development and production. Transport the definition in the solution and supply the destination value during deployment, allowing multiple consuming components to reuse one parameter.

Trap Hard-coding the production site in each component before export, although that requires changing the application for each environment.

3 questions test this
An environment variable's current value takes precedence over its default value

A defined current value is used even when a default value exists. The default is the fallback when no current value exists, so changing only the default will not replace an explicit destination value.

Trap Editing the default to override an existing production current value, although current-value precedence keeps the explicit value in use.

3 questions test this
Remove source values from the solution when destinations need their own values

Before export, use Remove from this solution on the environment variable's current value when it should not travel to the next environment. The development value remains in the source environment, while deployment can supply a different destination value.

Trap Deleting the variable definition to avoid exporting the source value, although consuming components need the definition to resolve the parameter.

3 questions test this
Secret environment variables use Azure Key Vault configuration

Use a Secret environment variable for a secret that components must reference through Azure Key Vault. Configure the required vault access rather than treating an ordinary Text variable as a dedicated secret store.

Trap Using a Text environment variable as the secret-management mechanism, although it does not provide the Secret type's Key Vault integration.

3 questions test this
Connection references bind solution components to destination connections

A connection reference is a solution component that points to a connector connection, while the connection contains authentication information. Bind references to usable target connections during import; use environment variables separately for parameters such as SharePoint sites and lists.

Trap Using a data-source environment variable to carry authentication, although it stores parameters rather than the connection's credentials.

3 questions test this
Adding an existing flow to a solution does not immediately replace its direct connections

A flow created outside a solution initially retains direct connections after it is added to a solution. Use the flow checker's Use connection references migration action, or export and import the unmanaged solution, to replace those connections with solution-aware references.

Trap Assuming Add existing automatically converts all flow connections, although connection-reference migration is a separate step.

3 questions test this
Activating a deployed flow requires access to every referenced connection

The user initially turning on a flow must own or have permission to use all its connections. A ConnectionAuthorizationFailed error therefore calls for checking connection permissions or activation by the connection owner, not merely changing the solution publisher.

Trap Assigning solution ownership to fix connection authorization, although ownership of solution metadata does not grant use of each underlying connection.

3 questions test this
Import custom connectors before the references and flows that depend on them

Custom connectors need to be imported in a separate solution before their connection references or dependent flows. Plan this dependency sequence rather than expecting one combined import to establish the connector and all its consumers reliably.

Trap Packaging the custom connector and its connection references into a single first import, although the connector must already be available for the dependent import.

3 questions test this
Pipelines promote the same exported artifact through sequential stages

A pipeline exports the solution when deployment is requested and promotes that same artifact through the later stages. It does not re-export development changes for each stage, ensuring that the artifact reaching production is the one that passed earlier validation.

Trap Editing development after QA and expecting the new changes in the same production promotion, although the pipeline retains the original export.

3 questions test this
Pipelines deploy solutions and configuration rather than Dataverse business records

Pipelines deploy solution components and target configuration such as environment variables and connection references. They do not carry the business data stored in Dataverse tables, so plan a separate data-migration mechanism when records must move too.

Trap Relying on pipeline deployment to copy customer rows with their table schema, although business records are not included in the solution artifact.

3 questions test this
Production pipeline targets must satisfy Managed Environments requirements

A production destination used by Power Platform pipelines must be enabled as a Managed Environment. The pipeline host is recommended to be production but does not itself have to be managed; distinguish the host's orchestration role from the destination requirement.

Trap Enabling Managed Environments only on the host to satisfy production-target requirements, although the destination has its own requirement.

2 questions test this
Native Power Platform pipelines do not deploy across tenants

When deployment must cross Microsoft Entra tenants, use an ALM approach such as Azure DevOps or GitHub rather than native Power Platform pipelines. Cross-region support within a tenant does not imply cross-tenant deployment support.

Trap Enabling Cross-Geo Solution Deployments to support another tenant, although that setting addresses geography rather than tenant boundaries.

4 questions test this
Publish customizations before requesting pipeline deployment

Pipelines do not automatically publish unmanaged customizations before exporting. Publish the components that require publication in development before requesting deployment so that the exported artifact includes the intended published changes.

Trap Using the pipeline request as the publication step, although the pipeline does not publish those unmanaged customizations.

3 questions test this
Pipeline prevalidation checks dependencies and target configuration before deployment

Pipelines prevalidate the solution against the target and collect connection and environment-variable configuration before deployment. Resolve missing dependencies and invalid configuration at that stage instead of planning to repair every environment manually after import.

3 questions test this

Build Dataverse data models

Read full chapter
  • The data workspace can generate and refine tables from natural language
  • Removing an existing table from the workspace does not delete its data
  • The data workspace supports only a subset of relationship configurations
  • Some column types require a designer outside the data workspace
  • External-data table creation previews only part of the dataset before saving
  • The data workspace supports an existing parent with a new child
  • Standard tables can be extended when their customizable property allows it
  • A table's display name can change while its schema name cannot
  • Activity tables provide a shared structure for time-based work
  • Virtual tables expose external data dynamically rather than importing it
  • Elastic tables suit very large high-throughput datasets
  • Change tracking and auditing solve different data-history requirements
  • Enable Attachments lets a table's records carry notes and files
  • Enabling activities makes the table available to the Regarding lookup
  • Table ownership must be chosen before the table is created
  • Alternate keys identify records through unique business values
  • A duplicate detection rule must be published before it is usable
  • Base and matching record types define which records a duplicate rule compares
  • Duplicate matching can compare whole values or a specified end of a value
  • Case-sensitive duplicate rules distinguish letter casing
  • Inactive matching records can be excluded from duplicate detection
  • Ignore Blank Values prevents missing data from counting as an equal match
  • Dependencies can block deletion of a custom table
  • A configured Quick Find view does not by itself enroll a table in global search
  • Can be taken offline enables a table to participate in offline data access
  • Both participating tables must allow connections
  • Table-level SharePoint document management participates in organization-level integration
  • Can have a contact email enables sending email using a table's stored address
  • Choose a column's schema name and data type before saving it
  • Use Multiline Text for content beyond the Text Area limit
  • Choice stores one selection while Choices allows multiple selections
  • Global choices centralize option sets reused by multiple columns
  • Decimal numbers preserve specified values while floating point stores approximations
  • Currency columns support transaction currencies and base-currency values
  • Date and time behavior determines whether users see timezone conversion
  • Customer columns can reference either an account or a contact
  • Autonumber generates formatted text when a row is created
  • Searchable controls discovery in Advanced Find and view customization
  • Business-required columns do not impose SystemRequired enforcement on API writes
  • A File column stores binary content associated with a row
  • File uploads and deletions take effect before a model-driven form is saved
  • Required-field validation does not enforce File columns
  • Choose the Autonumber format to match the required reference structure
  • The Autonumber seed sets the starting numeric value
  • Status Reason options provide configurable detail within a Status
  • Whole number is the column type for integral values
  • Whole number minimum and maximum settings define the permitted range
  • Duration formats a Whole number as an interval measured in minutes
  • Email format validates an email address and presents a mailto link
  • URL format validates an address and renders a link to open it
  • Rich text supports formatted multiline content
  • A lookup on the child table implements a one-to-many relationship
  • Many-to-many relationships use an intersect table for reciprocal associations
  • Remove Link preserves child records when the parent is deleted
  • Restrict prevents parent deletion while related rows exist
  • Cascade All deletes dependent rows with the parent
  • Cascade User Owned limits cascading to children owned by the same user
  • Cascade Active selects active children while Cascade None leaves children unchanged
  • Formal table relationships and informal connections serve different modeling needs
  • Association-specific data requires an explicit junction table
  • Referential presets keep parent operations from propagating to child records
  • The Parental preset makes related records follow parent actions
  • Custom relationship behavior permits different policies for different actions
  • Share cascading controls access propagation when a parent is shared
  • Unshare cascading controls propagation when parent sharing is withdrawn
  • Reparent cascading addresses access effects when a child changes parent
  • Self-referential N:N relationships need labels that distinguish their two roles
  • Deleting a native N:N relationship deletes its stored associations
  • An existing cascading parent can block a new cascading relationship
  • A custom parent table cannot cascade actions to a system child table
  • Changing access cascading to Cascade None requires cleanup of earlier inherited access
  • Inherited-access cleanup preserves directly granted access
  • Separate related business entities to avoid repeated and sparse data
  • Prompt columns persist AI-generated enrichment in the table
  • Prompt columns ignore unsupported input column types
  • A table can have up to five prompt columns
  • Asynchronous prompt definitions require a single record-ID text input
  • Prompt-column tests can target a specific record before saving
  • Prompt columns execute on record creation or changes to referenced inputs
  • Updated prompt columns generate values asynchronously
  • Prompt-column filters determine whether an eligible record receives AI processing
  • Prompt-column Status and Details distinguish failures from skipped execution
  • Existing rows can be backfilled through an enabled asynchronous bulk job
  • Imported prompt-column bulk jobs require review by default
  • Prompt-column execution requires both platform enablement and the column execution setting
  • A configured row summary applies to all main forms and views for its table
  • Row summaries require environment enablement and existing table data
  • Row-summary prompts define the included columns and presentation
  • LanguageCode makes row summaries follow the user's language preference
  • Some Dynamics 365 tables use their own summary features instead
  • Show row summary hides custom summaries without deleting the prompt
  • Row summaries move through solutions as selected AI Skill Config records
  • Row summaries are not a supported engine for arithmetic or date decisions
  • A table view defines displayed columns, row filtering, and default sorting
  • Quick Find determines which columns are searched in Quick Find and lookup searches
  • The Lookup view defines the record-selection presentation for a lookup
  • The Associated view controls the default listing of related records
  • Advanced Find supplies default columns for new views without a template
  • Special-purpose system views cannot be deleted or deactivated
  • Set and publish the table's default public view explicitly
  • Quick Find find columns define the fields searched by Dataverse global search
  • Quick Find view columns define the displayed global-search result fields
  • Quick Find filter conditions constrain Dataverse global-search results
  • Main forms are the primary table assets for record interaction
  • Tabs provide primary grouping and sections organize content inside each tab
  • The form designer separates table fields from structural components
  • A main form's title is user-visible while its description explains it to makers
  • Displaying a record image requires both a primary image column and the form setting
  • Save and publish main-form changes to make them available to users
  • A main form can be reused across device sizes
  • Dataverse combines privileges from all assigned security roles
  • Each table privilege has its own access level
  • Business Unit access excludes subordinate units unless Parent: Child access is granted
  • Organization-owned tables expose organization-wide or no access rather than owner-level scopes
  • Associating records requires the correct Append and Append To privileges
  • Sharing grants access while assignment changes ownership
  • Environment Maker access does not automatically grant Dataverse data access
  • Table customization authority is separate from business-record access
  • Solutions can transport security roles and column security profiles
  • Configure the security structure and assignments in each destination environment
  • Business units form a hierarchy beneath a single root
  • The root business unit cannot be deleted
  • Owner teams hold records and roles while access teams receive shared access
  • A team can include users from multiple business units
  • Microsoft Entra group teams derive membership from the directory group
  • Hierarchy security extends record access but still requires table Read privileges
  • Manager hierarchy follows reporting lines while position hierarchy follows assigned positions
  • Hierarchy access is broader for direct reports than for indirect reports
  • Dataverse maintains a business unit's default team membership automatically
  • Column security requires enabling the column and granting profile permissions
  • Column security separates reading, creating, and updating a value
  • System administrators bypass column-level security
  • Primary name values are unsuitable for sensitive information
  • Sensitive prompt inputs do not automatically secure generated output
  • Not every Dataverse column supports column-level security
  • Secure the contributing columns to protect composite address data

Unlock with Premium — includes all practice exams and the complete study guide.

Create intelligent applications

Create model-driven apps

Read full chapter

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

Create canvas apps

Read full chapter
  • Uploading Excel data and connecting to a workbook create different data arrangements
  • A form's Item selects a record while DataSource selects its table
  • NewForm switches an edit form to data-source defaults
  • ResetForm discards edits that navigation alone would retain
  • SubmitForm validates entries and signals the save outcome
  • LastSubmit exposes server-generated values after a successful form save
  • Patch changes specified fields without replacing the whole record
  • Patch creates a row when its base record comes from matching Defaults
  • Later Patch change records override earlier values for the same field
  • Batch Patch matches base and change records one for one
  • A gallery repeats its template over the table in Items
  • Filter returns a matching table while LookUp selects the first match
  • Display forms and View mode provide read-only record presentation
  • Data-card bindings determine which values a form writes
  • Deleting a persisted record requires Remove to target its connected data source
  • Delegation depends on the complete expression and its data source
  • Nondelegable queries process only a bounded initial set of source records
  • Membership delegation applies to columns of the base data source
  • Loading a collection does not bypass source retrieval limits
  • Explicit Column Selection reduces retrieved columns rather than rows
  • DelayOutput reduces recalculation while a user types
  • Concurrent accelerates independent calls but cannot order dependent work
  • References to unloaded-screen controls can force those screens to load
  • StartScreen selects the opening screen without blocking on OnStart
  • Per-row related lookups can multiply gallery network requests
  • Smaller collection caches reduce client memory pressure
  • Removing unused media and right-sizing images reduces the app's loading footprint
  • AccessibleLabel supplies meaningful screen-reader descriptions
  • Keyboard navigation should use logical structure and nonpositive tab-index choices
  • Custom text colors need sufficient contrast with their background
  • Semantic headings and buttons communicate structure and interaction
  • Pen input needs an alternative method for accessible signatures
  • Accessible multimedia requires captions and transcripts
  • A combo box supports multiple selections and returns them through SelectedItems
  • Combo-box searching needs text fields and a delegable Items expression
  • Unsaved identifies edits that need protection before record switching
  • Back returns through screen history while Navigate names a destination
  • SetFocus requires an eligible control on the calling formula's screen
  • IsMatch validates a text pattern rather than merely the presence of input
  • Combo-box selections are not retained while a containing gallery scrolls
  • A Boolean Visible formula conditionally hides or shows a control
  • DisplayMode distinguishes editable input, readable output, and disabled interaction
  • A Drop down with AllowEmptySelection false selects an item before user input
  • Focused border properties make the keyboard focus position visible
  • A label's Live property controls how screen readers announce changing messages
  • Responsive layout starts by turning off Scale to fit
  • Auto-layout containers position their children automatically
  • Relative dimension formulas preserve layout as a parent changes size
  • SizeBreakpoints determines the screen-size classifications used by layout formulas
  • Dragging controls can replace responsive formulas with constants
  • A flow must have a Power Apps trigger before it can be added to an app
  • Adding a flow does not automatically call it from the selected control
  • Power Apps V2 declares the inputs supplied by the canvas app
  • A file input carries file content and its name
  • Flows edited outside Studio must be refreshed in the app
  • Remove from app detaches a flow without deleting it
  • Flow inputs from an app require server-side validation
  • Named formulas provide reusable values that update with dependencies
  • Named formulas cannot perform behavior actions or form circular dependencies
  • User-defined functions add typed parameters to reusable Power Fx logic
  • Behavior user-defined functions wrap side effects in a braced body
  • Power Fx user-defined functions do not support recursion
  • With names intermediate values within a single formula
  • Coalesce selects the first value that is neither blank nor an empty string
  • Editing a component definition updates its instances in the app
  • Custom input and output properties define a component's interface
  • App scope is optional for local components but unavailable in a library
  • Published component-library changes require adoption by consuming apps
  • A locally customized component copy no longer receives library updates
  • A maker must have access to a component library to import it
  • Screens in a component library exist for testing rather than end-user delivery
  • Canvas components cannot be inserted into galleries or forms
  • Component libraries do not support adding and running Power Automate flows
  • A canvas component library cannot host code components
  • Set creates app-wide state while UpdateContext creates screen-local state
  • Navigate can initialize the destination screen's context
  • A context variable shadows a same-named global value
  • Collect appends records while ClearCollect replaces a collection's contents
  • Clear removes collection rows but preserves its columns
  • Collections are mutable snapshots rather than automatically refreshed queries
  • Collect adds a table's rows individually unless the table is wrapped in a record
  • Variable-defining formulas must agree on the variable's type
  • Context-variable values survive navigation away from their screen
  • Session state must be explicitly persisted to survive closing the app
  • Remove deletes a selected collection record without clearing the working set
  • Direct property formulas recalculate derived values without variable reassignment
  • Formula-level error management must be enabled for current error semantics
  • IfError can replace a failed calculation at the point of use
  • App.OnError centralizes reporting for unhandled errors
  • Semicolon-chained actions do not stop automatically after an error
  • Errors returns structured information about prior data-source operations
  • AllErrors preserves multiple failures that FirstError alone cannot describe
  • Conflict handling depends on the data source's conflict-detection support
  • A failed ForAll iteration does not stop the remaining iterations
  • Live monitor can trace either an authoring session or a published app
  • Debug published app adds source expressions at a performance cost
  • HTTP 429 events in Live monitor indicate request throttling
  • Test Studio automates canvas-app UI regression scenarios
  • Test cases in a suite share app state and run sequentially
  • Assertions make a recorded interaction test an outcome check
  • Test Studio does not cover every canvas control type
  • A Data row limit of one makes local query evaluation easier to detect
  • Accessibility Checker identifies potential issues rather than certifying the app
  • Trace adds custom diagnostic events to Live monitor
  • Live monitor network details distinguish latency, payload size, and failed requests
  • Canvas Live monitor requires Environment Admin or Environment Maker membership
  • Agent builder combines an existing canvas app's metadata with an automation goal
  • Agent builder requires specific environment capabilities and settings
  • Generated agent instructions need review before creation
  • The generated agent is edited, tested, and published in Copilot Studio
  • Missing source connections can leave a generated agent without usable actions
  • Agent builder is canvas-only and excludes deprecated Excel connectors
  • Autonomous operation requires actions that do not prompt users for credentials

Unlock with Premium — includes all practice exams and the complete study guide.

Build business application logic and automation

Create cloud flows

Read full chapter
  • The initiating event determines the cloud flow type
  • Recurrence can specify selected weekdays and local times
  • Trigger conditions prevent unnecessary runs
  • Polling and webhook triggers handle downtime differently
  • Trigger concurrency can serialize separate flow runs
  • Split On creates separate runs from a trigger array
  • Turning off a flow preserves runs that have already started
  • Copilot turns a natural-language requirement into an editable cloud flow
  • Change type selects which row operations trigger the flow
  • Trigger scope selects the monitored ownership range
  • Select columns filters update requests rather than comparing values
  • Filter rows evaluates values after the row is saved
  • Select columns excludes lookup columns and virtual tables
  • Row triggers require Callback Registration privileges
  • Run as can use the modifying user's context for Dataverse actions
  • When a row is selected starts user-requested automation with row context
  • When an action is performed responds to a Dataverse business action
  • A Dataverse row-triggered flow cannot roll back the originating save
  • The Dataverse row trigger can defer triggering until a UTC timestamp
  • Custom connectors expose services not covered by prebuilt operations
  • A connection supplies authentication for a connector
  • Connector entitlement is evaluated separately from the business task
  • Classic data policies constrain connector combinations
  • Planner connector task creation targets supported basic plans
  • Connector throttling can constrain a flow before platform limits do
  • Run-only access permits execution without design access
  • Run-only connection settings determine the downstream identity
  • A cloud flow invokes desktop automation through a desktop-flow connection
  • Desktop-flow input and output variables carry data across the cloud boundary
  • Send a copy provides an independently maintained flow definition
  • An active co-owner does not replace a departed owner's connections
  • Create an approval does not wait for a decision
  • Approval types determine whose response completes the request
  • Custom responses combine custom choices with a completion policy
  • Sequential approvals request decisions in a defined order
  • Outcome supplies the decision while Responses supplies reviewer details
  • Long-running approvals require persistence beyond a single run
  • Guest approvers respond through the Power Automate portal
  • Assigned to accepts semicolon-separated supported identities
  • Custom notifications can link to approvals but are not actionable approval emails
  • Compose provides a reusable output without mutable state
  • Select reshapes objects while Filter array chooses objects
  • Filter array compares text case-sensitively
  • Join converts an array into a delimited string
  • Table operations serialize arrays for different destinations
  • Variables must be initialized at the flow's global level
  • Variable updates must match the stored type and intended operation
  • A known row identifier calls for Get a row by ID rather than a collection query
  • Update and delete actions target the row identifier from earlier flow data
  • Dataverse lookup inputs combine the entity set name with the related row identifier
  • Relate rows and Unrelate rows change associations between existing records
  • Search rows retrieves keyword matches across indexed Dataverse data
  • Search mode controls whether any or all search terms must match
  • Search rows filters restrict the records and tables searched
  • New Dataverse rows can be absent from Search rows until indexing catches up
  • Nested flow expressions pass one function's result into another
  • Parse JSON exposes response properties as downstream dynamic content
  • A Dataverse changeset makes its row operations succeed or fail together
  • Changeset actions cannot consume another action's output inside the changeset
  • Perform a bound action invokes an operation in its Dataverse table context
  • Download a file or an image returns content from a selected Dataverse column
  • Upload a file or an image writes supplied content to a Dataverse row column
  • List rows requires paging configuration to retrieve beyond its first page
  • Search type selects the query syntax used by Search rows
  • Condition handles relational tests while Switch matches exact values
  • Apply to each repeats actions over an array
  • Sequential iterations preserve predictable shared-variable updates
  • Do until repeats work until its condition or a limit is reached
  • Run after selects paths according to execution status
  • Scopes allow group-level error handling
  • Terminate stops execution with an intentional final status
  • Flow checker complements runtime testing
  • Failed action details identify the execution fault
  • Run-history columns can expose trigger values for diagnosis
  • Repair tips send failure guidance to owners
  • Authentication failures require connection and access checks
  • Invalid requests and transient failures need different remedies
  • A test-view timeout does not necessarily stop the flow
  • Callback Registration system jobs reveal Dataverse trigger-delivery attempts
  • Copilot can explain cloud-flow errors in the new designer
  • Per-flow analytics exposes aggregate execution and failure patterns
  • Missing FlowRun records do not prove that a solution cloud flow never ran

Unlock with Premium — includes all practice exams and the complete study guide.

Create prompts and models in AI Hub

Read full chapter
  • Templates are editable starting points for saved prompts
  • Effective prompts supply both a task and relevant context
  • Audience and output constraints belong in the instructions
  • Prompt tests exercise sample inputs before integration
  • Apps and flows consume saved prompts rather than the prompt library
  • Prompt builder requires Dataverse in a supported environment region
  • Prompt execution depends on available capacity as well as a valid definition
  • Named text inputs make prompts reusable for changing content
  • File and text inputs can be combined in one prompt
  • Office file analysis requires code interpreter
  • File inputs have independent size, page, and processing limits
  • Accepted documents can still produce incomplete extraction
  • Power Fx inputs compute context before generation
  • Runtime inputs carry data rather than trusted instructions
  • Knowledge filter attributes support a defined set of data types
  • Knowledge grounding supplies organization-specific context
  • Knowledge objects identify the data columns used by a prompt
  • Knowledge filters can bind to prompt inputs
  • Dataverse knowledge supports limited relationship traversal
  • Record retrieval limits the data supplied as knowledge
  • Connector-based knowledge is restricted to Power Automate consumption
  • Prompt settings can include links to retrieved records
  • Model choice balances reasoning, latency, and consumption
  • Temperature changes variability rather than guaranteeing correctness
  • GPT-5 reasoning does not expose the temperature slider
  • Content moderation controls filtering rather than creativity
  • Preview and experimental models require evaluation rather than assumed production readiness
  • The model context window constrains each invocation
  • JSON output exposes separate elements for downstream actions
  • Custom JSON examples preserve structure across authoring tests
  • Saving fixes the output format used at runtime
  • JSON configuration uses keyed examples instead of direct schema editing
  • Conflicting instructions can prevent valid JSON generation
  • Canvas apps call added prompts through Predict
  • Run a prompt maps flow data into prompt inputs
  • The flow action provides an entry point for custom prompt authoring
  • Prompt sharing separates use from editing privileges
  • Text approval preserves a reviewer's accepted revisions
  • Generated content needs human review before external or consequential use
  • AI models support function calls and purpose-built app components
  • Available AI model data sources depend on model access
  • Explicit invocation and result reuse avoid unnecessary predictions
  • Language detection returns an identifier and confidence
  • Classification labels text while entity extraction returns values inside it
  • Sentiment and key phrases answer different analysis questions
  • Text recognition reads content while object detection locates trained objects
  • AI Builder actions should retain Asynchronous Pattern enabled
  • Process documents requires a published model and file content
  • A document page range should contain one complete form
  • Extracted values and confidence are distinct outputs
  • Extracted document tables require row-level processing
  • Extracted text needs conversion before numeric storage
  • Inline email images should be filtered before document extraction
  • Prebuilt models avoid training when a standard task already fits
  • Generic prediction models cannot be invoked from apps or flows
  • Custom models need training and publication before consumption
  • Publishing replaces the previously published model version
  • Model co-owners can retrain and publish but cannot delete

Unlock with Premium — includes all practice exams and the complete study guide.

Implement business and process logic

Read full chapter
  • A specific form scope limits a business rule to that form
  • Canvas apps use table-scoped rules without model-driven UI actions
  • Business rules implement conditional validation and value changes
  • Active business rules must be deactivated before editing
  • Form rules need their referenced columns on the form
  • Business rules exclude some column types
  • Unified Interface rules should reference component columns
  • Editable subgrids do not support business rules
  • A business-rule recommendation waits for the user's acceptance
  • Set Default Value initializes only an empty column
  • Set Business Required changes a column's form requirement conditionally
  • Business process flows guide users through stages
  • Required steps gate movement to the next stage
  • A required Yes/No process step must be Yes
  • Saved process drafts are unavailable until activated
  • Process order selects the first eligible default
  • Switching processes preserves each instance's state
  • Process definitions have table, stage, and step limits
  • Offline process use requires a single-table process
  • Business process instances require privileges on their own process table
  • A custom table must be enabled for business process flows before participating
  • Enabling business process flows on a custom table cannot be undone
  • Branching conditions use steps from the preceding stage
  • One branching rule cannot mix AND and OR
  • Peer branches must converge consistently or end
  • Visible branch structure can disclose sensitive process information
  • Stage relationships enable reuse of related rows
  • Flow Steps run instant cloud flows from inside stages
  • Action Steps invoke actions or on-demand workflows
  • Stage and global workflows respond to different process events
  • A successful Flow Step needs its process log updated to record completion
  • Flow Step status display requires read access to System Jobs
  • Column values set by business rules or form scripts also appear in the process control
  • Hiding a form column also hides it in the business process flow control
  • Data entered through process steps also updates form columns
  • Calculated columns derive values from the current row and its parent
  • Parent references require a supported table-specific lookup
  • Calculated output may require protection independently of its inputs
  • Calculated chains are bounded and cannot be cyclic
  • Certain calculated dependencies disable sorting
  • Calculated-column DIFF functions require matching date behaviors
  • Calculated-column ADDDAYS takes the day count before the date
  • Calculated columns cannot trigger workflows or plug-ins
  • Calculated columns do not trigger duplicate detection rules
  • An existing simple column cannot be converted into a calculated column
  • Rollups aggregate qualifying related records
  • Rollup refresh is asynchronous
  • Manual recalculation requires source-row write access
  • Manual rollup limits differ from background calculation limits
  • Accessory columns expose rollup freshness and errors
  • Rollups follow configured relationships rather than every associated-grid row
  • Rollups calculate in system context rather than per viewer
  • Rollup precision is applied before aggregation
  • A rollup cannot aggregate another rollup column
  • A rollup cannot reference a calculated column that depends on another calculated column
  • Updating a rollup value cannot trigger a workflow
  • A workflow wait condition cannot use a rollup column
  • Formula input support depends on column format as well as type
  • Formula ranges constrain intermediate calculations rather than offering editable field limits
  • A formula expression determines its column's result type
  • Formula arithmetic treats numeric nulls differently from calculated arithmetic
  • Formula columns convert supported currency inputs but cannot return Currency
  • Numeric text conversion requires an explicit supported format
  • Formula date calculations must respect date behavior compatibility
  • Formula dependencies are bounded and cannot be circular
  • Only suitable simple formulas can feed rollups
  • Formula columns have offline, sorting, and trigger restrictions
  • Dataverse functions centralize parameterized server operations
  • Functions access data in the invoking user's context
  • Apps invoke Dataverse functions through Environment
  • Existing apps need refreshed Environment metadata for new functions
  • Cloud flows invoke functions with Perform an unbound action
  • Responsive app logic and longer-running orchestration favor different execution surfaces
  • Transaction-bound Dataverse Power Fx logic keeps related database changes atomic
  • Power Fx server logic can return an Error to the invoking app or flow
  • An automated low-code plug-in selects a data event on its associated table
  • The automated plug-in stage determines whether logic precedes or follows the data change
  • Low-code plug-in expressions access Dataverse tables with native Power Fx functions
  • Low-code plug-in connector calls use the connection reference's internal name
  • Dataverse function tracing requires plug-in trace logging

Unlock with Premium — includes all practice exams and the complete study guide.