AB-410 Study Guide

Before you build anything, you map a business requirement to the right Power Platform component. The exam gives you a scenario and expects you to pick the component that fits, so knowing what each one is for is more useful than knowing how to build it.

What you need to know

• Dataverse stores structured business data in tables, and it is the data platform every intelligent app should default to
• Canvas apps give you pixel-level control over the screen and are best for task-focused, mobile-first experiences
• Model-driven apps generate their UI from the data model and are best for data-dense, process-driven work
• Power Automate cloud flows handle automation, integration, and approvals
• Copilot Studio agents handle conversational and autonomous scenarios, and AI Hub prompts and models add generative AI to apps and flows
• Power Pages is the choice when an external or public-facing website is part of the requirement

Microsoft Learn resource: Modernize applications with Power Platform (opens in a new tab)

Microsoft ships ready-made agents and Copilot experiences across Power Platform, and part of designing a solution is deciding whether a built-in agent already covers a requirement before you build a custom one. Reusing what exists is faster, cheaper, and easier to govern.

What you need to know

• Copilot is built into Power Apps, Power Automate, Power Pages, and Dataverse to help makers build and to help users work
• Copilot Studio has prebuilt and template agents you can start from, and the Agent Store offers agents you can add rather than build
• Evaluate a built-in agent on fit, the data and knowledge it can reach, and whether it can be governed in your tenant
• Building a custom agent in Copilot Studio is the fallback when no built-in agent meets the requirement

Microsoft Learn resource: Copilot Studio overview (opens in a new tab)

Low-code covers most needs, but the exam expects you to know the escape hatches for when it does not, and to recommend the lightest option that solves the problem. Reach for pro-code only when low-code cannot do the job.

What you need to know

Reach for these in order, lightest first:

• Power Fx low-code plug-ins (functions): server-side business logic written in Power Fx, reusable across apps and flows, no traditional code
• Custom connectors: wrap any REST API so a flow or app can call it like a built-in connector
• Power Apps component framework (PCF): custom code components (controls) for canvas and model-driven apps when a standard control is not enough
• Plug-ins and Azure Functions: professional C# code for complex server-side logic or external integration

Microsoft Learn resource: Use low-code plug-ins in Dataverse (opens in a new tab)

An environment is a container for your apps, flows, and one Dataverse database, and choosing the right type is a common exam scenario. The key is matching the environment type to the stage of work.

What you need to know

Exam tip: Every environment has at most one Dataverse database, and the default environment cannot be deleted.

Microsoft Learn resource: Power Platform environments overview (opens in a new tab)

Solutions are how you package and move your work between environments, and they are the foundation of application lifecycle management. Knowing the difference between the two solution types is one of the most testable facts in this domain.

What you need to know

• You develop in an unmanaged solution, then export it as managed to deploy downstream
• Every solution has a publisher with a customization prefix that is added to new components
• Pipelines in Power Platform automate deployment from dev to test to production without manual export and import

Microsoft Learn resource: Overview of application lifecycle management with Microsoft Power Platform (opens in a new tab)

Tables hold your data in Dataverse, and the data workspace in Power Apps gives you a visual designer where you create tables, add columns, and draw relationships on one canvas. You create tables from Power Apps at make.powerapps.com under Tables.

What you need to know

• Choose row ownership (User or team, or Organization) when you create the table; this cannot be changed afterward
• Every table gets a primary name column and system columns such as created on and modified by, which you cannot delete
• Changes are not saved until you select Save Table
• You need the System Customizer or System Administrator role to create tables

Microsoft Learn resource: Create and edit tables using Power Apps (opens in a new tab)

Dataverse ships with standard tables such as Account and Contact that come from Power Apps and Dynamics 365, and you can use them, extend them, or create your own custom tables. Knowing the difference matters because standard tables behave differently from custom ones.

What you need to know

• Standard tables are included with the platform; you can add custom columns to them but cannot delete their standard columns
• Custom tables are the ones you create, and you can fully control and delete them
• The Tables list filters by Recommended (standard), Custom, and All
• Prefer extending a standard table over building a custom one when a good match already exists

Microsoft Learn resource: Types of tables (opens in a new tab)

Beyond its columns, a table has properties that turn on capabilities such as search, offline access, and attachments. Some of these are set once at creation and cannot be undone, which makes them exam-worthy.

What you need to know

• Row ownership (user or team versus organization) is chosen at creation and is permanent
• Appear in search results lets rows show up in app search
• Can be taken offline makes the table available in the mobile app without a connection
• Enable attachments adds notes and file attachments to rows, and it cannot be turned off later
• Installing Dynamics 365 apps in an environment is also a one-way decision made at creation

Microsoft Learn resource: Create and edit tables using Power Apps (opens in a new tab)

Columns define what each table stores, and the data type you pick controls how the value is stored and displayed. The most tested trap is what you can and cannot change after a column is saved.

What you need to know

• Display name can change any time; Name (the schema name with the publisher prefix) is locked once saved
• Data type cannot be changed after saving, with the one exception of text to autonumber
• Required does not hard-enforce data through every connection; use a business rule when you need real enforcement
• Searchable controls whether the column appears in advanced find and view customization
• Common types include text, choice, lookup, date and time, currency, and the newer prompt type

Microsoft Learn resource: Create and edit columns in Dataverse using Power Apps (opens in a new tab)

Relationships connect tables so you avoid repeating data and can navigate between related rows. There are three types, and the exam expects you to pick the right one for a scenario.

The three relationship types:

1. One-to-many (1:N): one row in table A relates to many rows in table B; for example, one classroom hosts many classes
2. Many-to-one (N:1): the same relationship seen from the other side; adding a lookup column automatically creates a many-to-one relationship
3. Many-to-many (N:N): rows on both sides relate to many rows on the other; for example, students and the classes they attend

Exam tip: You can set cascade behaviors (such as delete and assign) on one-to-many and many-to-one relationships, but not on many-to-many.

Microsoft Learn resource: Microsoft Dataverse table relationships (opens in a new tab)

A prompt column is one of the newer AI-powered data types in Dataverse. You attach a natural-language prompt to a column, the AI model runs it against other columns in the row, and the generated result is stored in the column so it is ready to use in apps, flows, and reports.

What you need to know

• A prompt column stores the generative AI result persistently in the table, unlike a live prompt call
• Set the Data type to Prompt when you create the column, then write the prompt
• You can create up to five prompt columns per table
• It uses the same licensing as AI Builder prompts, and the Copilot and AI prompts feature must be turned on for the environment
• Common uses are summarizing, classifying, extracting, and sentiment on the row's own data

Microsoft Learn resource: Prompt columns (opens in a new tab)

A row summary is a Copilot-generated overview of a record that saves users from scanning dozens of fields. You write a prompt that tells the model which columns to include, and the summary shows up in a consistent place on the form or in a grid.

What you need to know

• Summaries appear in the Insights bar at the top of a main form and from the inline Summary action in a view
• A Power Platform admin must turn on the AI insight cards environment setting first
• In the prompt, list the columns to include or exclude, and set formatting such as a bulleted list
• Add the LanguageCode input and a language instruction so the summary respects the user's language
• Row summaries do not do calculations or date math; use calculated columns or business logic for those

Microsoft Learn resource: Configure a row summary for a model-driven app (opens in a new tab)

Views define which columns, filters, and sort order users see in a grid. Public views are shared system views (as opposed to personal views a user saves for themselves), and you build them in the view designer.

What you need to know

• A public view is a system view that everyone with access to the table can use
• In the view designer you add or remove columns, set the sort order, and edit filters
• You can configure multi-column sorts by holding Shift while choosing a sort
• Keep views lean; too many columns degrades grid performance
• A view definition can be downloaded as FetchXML for pro-code scenarios

Microsoft Learn resource: Understand model-driven app views (opens in a new tab)

The main form is the primary editing surface for a row in a model-driven app, and you design its tabs, sections, and columns in the form designer. Getting the form right is most of the model-driven user experience.

What you need to know

• Main forms are the full editing experience; other form types include quick create, quick view, and card forms
• Organize a form with tabs and sections, and add columns, subgrids, and related components
• Business rules can show, hide, require, or set values on form columns without code
• A required column on a hidden tab or section does not block saving unless it is also on a visible one
• Forms are assigned to security roles, so different users can see different forms for the same table

Microsoft Learn resource: Create, edit, or configure forms using the form designer (opens in a new tab)

Dataverse has a rich, role-based security model, and this skill is heavily tested. The core idea is that access is cumulative: a user's effective access is the sum of every role they hold directly and through teams, and the least restrictive permission wins.

What you need to know

• Security roles are collections of privileges; assign them to users directly or through teams
• Business units are containers that set security boundaries; every environment has a root business unit
• Table privileges are Create, Read, Write, Delete, Append, Append To, Assign, and Share
• Each privilege has an access level: Organization, Parent: Child Business Unit, Business Unit, User, or None
• Column-level security protects individual columns through a Column Security Profile, on top of (not instead of) record access

Exam tip: Access is always additive, so you cannot grant broad Organization read and then hide a single record; the broadest grant wins.

Microsoft Learn resource: Security roles and privileges for Dataverse (opens in a new tab)

Forms in a model-driven app come straight from the table's forms, so most of your work is choosing which forms the app uses and designing them well. The app itself does not redraw the form; it presents the table's form.

What you need to know

• A model-driven app uses the main, quick create, quick view, and card forms defined on its tables
• In the app designer you pick which forms are available; if you select none, users get all of them
• Each table must have at least one active form for the app to run
• Design the form once on the table and every app that uses the table benefits
• Assign forms to security roles to control who sees which form

Microsoft Learn resource: Create, edit, or configure forms using the form designer (opens in a new tab)

Views are the grids a model-driven app shows for each table, and you choose which system views the app exposes. As with forms, the view is defined on the table and reused by the app.

What you need to know

• Include public views in the app through the app designer; selecting none exposes all of them
• Users can switch between the views you make available and save their own personal views
• Edit columns, sorting, and filters in the view designer
• The default view is what opens first, so set it deliberately

Microsoft Learn resource: Understand model-driven app views (opens in a new tab)

Generative pages are an AI-first way to build pages in a model-driven app. You describe the page you want in natural language, point it at your Dataverse data, and the app agent generates a working page, including the code behind it.

What you need to know

• In the app designer, choose Add page and then Generative page, then describe the page
• The agent generates React code for both the layout and the logic, which you can view, edit, and iterate on
• A page can link up to six Dataverse tables, and Power Platform connectors are supported in preview
• You can attach an image or sketch to guide the look, and refine the page conversationally
• In-browser authoring reached general availability in late 2025 and is available in the United States, Great Britain, Australia, and Singapore

Exam tip: Generative pages are solution-aware, so they move between environments as part of the app's solution.

Microsoft Learn resource: Generate a page using natural language (opens in a new tab)

Composing the app means assembling its parts in the app designer: the tables, forms, views, charts, dashboards, and the navigation that ties them together. This is where the pieces become an app users can run.

What you need to know

• The app designer is where you add tables and their components and then validate and publish
• The site map defines the app's navigation with areas, groups, and subareas
• An app is built from components: tables, forms, views, charts, dashboards, and business process flows
• Select Publish to make the app available; users still need a security role to run it
• Use the modern app designer rather than the classic one for new apps

Microsoft Learn resource: Create a model-driven app with the app designer (opens in a new tab)

Not every user should see every form or view. You control this by associating forms and views with security roles, so the app shows each user the surface that fits their role.

What you need to know

• Assign a form to one or more security roles; a user sees the first form their role allows
• Order forms so the fallback form is sensible when a user has access to several
• Views are also governed by the roles that can read the table
• Use role-specific forms to hide sensitive columns from users who should not edit them
• This is presentation-level access; column-level security is what actually protects the data

Microsoft Learn resource: Manage model-driven app forms settings (opens in a new tab)

Publishing an app does not give anyone access to it. You share the app with users by assigning the security roles that are allowed to run it, which is a separate step from data security.

What you need to know

• Share a model-driven app by assigning one or more security roles to it
• A user needs both the app's role and the right privileges on the underlying tables to see data
• Sharing the app without table privileges shows the app but no records
• Manage sharing from the app's Share command in the maker portal

Microsoft Learn resource: Share a model-driven app (opens in a new tab)

Charts and dashboards turn table data into visuals inside a model-driven app. Charts sit on a table's views, and dashboards combine charts, lists, and other visuals on one screen.

What you need to know

• System charts are built in the chart designer and appear alongside a table's views
• Dashboards are built in the dashboard designer and can hold charts, lists, iframes, and embedded Power BI
• Charts respect the view's filters, so the same chart changes with the selected view
• Add charts and dashboards to the app through the app designer
• Power BI is the choice for cross-table or richer analytics beyond native charts

Microsoft Learn resource: Create or edit model-driven app dashboards (opens in a new tab)

Canvas apps give you a blank design surface and full control of the layout, and they connect to data through connectors. You can start from data or from blank in Power Apps Studio.

What you need to know

• Start from data (Dataverse, SharePoint, Excel, and hundreds of other connectors) or from a blank canvas
• Choose a layout: Responsive, Tablet, or Phone
• Dataverse is the recommended data source; SharePoint and Excel are common alternatives
• The three-screen pattern (browse, detail, edit) is generated for you when you start from data
• You need the Environment Maker role to create canvas apps

Microsoft Learn resource: Create a canvas app based on Excel data (opens in a new tab)

A good canvas app works for everyone and stays fast. The exam expects you to know the concrete settings and properties that make an app accessible and responsive, not just the principle.

What you need to know

• Run the Accessibility Checker to find issues before you ship
• Set the AccessibleLabel property so screen readers announce controls, and set TabIndex to 0 for interactive controls and -1 for non-interactive ones, never above 0
• Keep text-to-background contrast at 4.5:1 or greater
• Build responsive layouts so the app adapts to screen size instead of using fixed coordinates
• For performance, delegate queries to the data source and limit what loads on start

Microsoft Learn resource: Create accessible canvas apps (opens in a new tab)

Canvas apps can kick off automation by calling Power Automate cloud flows. This lets the app do things it cannot do alone, such as send approvals, write to other systems, or run long operations.

What you need to know

• Add a flow from the Power Automate pane, then call it with the .Run() function on a control event
• Pass values from the app into the flow as inputs and use returned values back in the app
• Instant (button) triggered flows are the usual pattern for app-initiated automation
• Use a flow when logic is too heavy for the app or needs a premium connector
• The flow runs under the connections and permissions it was built with

Microsoft Learn resource: Use Power Automate pane (opens in a new tab)

Repeating the same logic across an app is slow to maintain, so Power Fx gives you ways to define something once and reuse it. This skill names three of them, so know what each one is for.

The reusable building blocks:

1. Named formulas: define name = formula in the App Formulas property; the value is always available, always current, and cannot be overwritten elsewhere in the app
2. User-defined functions (UDFs): named formulas that take parameters and return a value, like your own Power Fx functions
3. Component libraries: reusable UI components shared across many apps, versioned and updated centrally

Exam tip: Named formulas beat setting a variable in OnStart because they have no timing dependency and can be calculated only when needed, which also helps load time.

Microsoft Learn resource: App object in Power Apps (opens in a new tab)

State in a canvas app lives in variables and collections, and choosing the right kind keeps an app predictable. Power Fx prefers formulas over variables, but you still need variables for imperative actions.

What you need to know

• Global variables are set with Set() and are available across every screen
• Context variables are scoped to one screen and set with UpdateContext() (or through Navigate)
• Collections are in-memory tables, created and filled with Collect() and ClearCollect()
• Prefer named formulas over variables when a value can be calculated rather than stored
• Use Patch(), SubmitForm(), or Collect() to write data back to a source

Microsoft Learn resource: Understand variables in canvas apps (opens in a new tab)

Apps that handle errors gracefully feel professional and are easier to support. Power Fx gives you functions to catch and respond to errors instead of letting them surface raw to the user.

What you need to know

• IfError() runs a fallback when an expression errors; IsError() tests whether one errored
• App.OnError is a single place to handle or log errors across the whole app
• Forms expose OnFailure and OnSuccess so you can respond to a save
• Use Notify() to show the user a clear, friendly message
• Turn on the modern Error handling features in app settings for the full behavior

Microsoft Learn resource: Error, IfError, IsError, IsBlankOrError functions (opens in a new tab)

Before an app ships you test it, and Monitor is the tool the exam wants you to know. Monitor shows a live trace of what the app is doing so you can find slow or failing operations.

What you need to know

• Monitor streams events in real time (data calls, control events, errors) while you use the app
• It works for both canvas and model-driven apps, and you can share a session to debug together
• Use it to spot slow data calls, delegation warnings, and unexpected behavior
• Test Studio records and replays automated tests for canvas apps
• Preview the app in Studio for quick checks, but Monitor is where you diagnose

Microsoft Learn resource: Live monitor overview (opens in a new tab)

You can turn a canvas app's knowledge and actions into a conversational agent. Agent builder in Power Apps reads the app and generates an agent you then refine in Copilot Studio.

What you need to know

• Agent builder uses the app's metadata plus your stated goal to generate a step-by-step process, knowledge, and triggers
• After it generates the agent, you edit, test, and publish it in Microsoft Copilot Studio
• Your environment needs a Dataverse database and the admin setting that allows publishing copilots with AI features
• This is different from adding a Copilot control to a canvas app, which embeds a chat experience over your data
• Block unmanaged customizations must be off for agent builder to work

Microsoft Learn resource: Build an AI agent to automate your business process (opens in a new tab)

Every cloud flow starts with a trigger, and the exam gives you scenarios where you pick the right one. The trigger decides when and how the flow runs.

The three cloud flow trigger types:

1. Automated: starts when an event happens, such as a Dataverse row being created or an email arriving
2. Instant: started on demand by a person, from a button, an app, or Copilot
3. Scheduled: runs on a recurrence you set, such as every morning at 8

Exam tip: For a flow that must react to data changes in Dataverse, choose the Dataverse When a row is added, modified or deleted automated trigger and scope it to the right change and columns.

Microsoft Learn resource: Triggers (opens in a new tab)

Connectors are how a flow talks to services, and knowing standard from premium affects both design and licensing. The exam expects you to recommend a connector that fits the requirement and the license.

What you need to know

• Connectors provide triggers (start a flow) and actions (do something in the service)
• Standard connectors are included with Microsoft 365; premium connectors (including Dataverse and HTTP) need a premium or per-flow license
• Custom connectors wrap any REST API when no built-in connector exists
• The Dataverse connector is premium and is the backbone of Power Platform automation
• Check the connector reference for whether an operation is a trigger or an action before you design

Microsoft Learn resource: Connectors overview (opens in a new tab)

Approvals are a first-class part of Power Automate, and the exam expects you to know the built-in approval action and its response types. Approvers can respond from email, the Approvals app, or Teams.

What you need to know

• Add the Start and wait for an approval action to pause the flow until a decision is made
• Approval types include Approve/Reject - First to respond, Everyone must approve, and Custom Responses
• After the action, use a Condition on the response to branch into approved and rejected paths
• Approval responses such as Approve are case-sensitive when you compare them
• Approvals can be assigned to more than one approver, in series or in parallel

Microsoft Learn resource: Create and test an approval workflow with Power Automate (opens in a new tab)

Actions are the steps a flow runs after the trigger, and configuring them means wiring in the right inputs, often using dynamic content from earlier steps. This is the everyday work of building a flow.

What you need to know

• Add actions from a connector, then fill their inputs with dynamic content from the trigger or earlier actions
• Use the expression editor for functions when a plain field is not enough
• Actions run in order top to bottom by default; branches and parallel branches change that
• Rename actions clearly, because expressions reference actions by name
• Common Dataverse actions include add a new row, update a row, get a row by ID, and list rows

Microsoft Learn resource: Move, delete, and add options to actions in a cloud flow (opens in a new tab)

Real flows make decisions and repeat work, and Power Automate has control actions for both. Knowing which control fits keeps a flow readable and correct.

What you need to know

• Condition creates an if yes and if no branch based on a comparison
• Apply to each loops over a collection or array of items
• Do until repeats until a condition becomes true, which suits polling and approval loops
• Switch branches on one value into several cases, cleaner than nested conditions
• Scope groups actions together and helps with structured error handling

Microsoft Learn resource: Add a condition to a cloud flow (opens in a new tab)

When a flow misbehaves you need to test it and read what went wrong. Power Automate gives you a test experience and a run history that shows each step's inputs and outputs.

What you need to know

• Use Test with I'll perform the trigger action or automatically to run the flow on demand
• The run history shows every step with its inputs, outputs, and any error
• The Flow checker flags errors and warnings before you save
• Configure run after lets an action run even when a previous one fails, which powers a Scope-based try and catch pattern
• Fix a failed run and resubmit it from the run history rather than rebuilding

Microsoft Learn resource: Troubleshoot a cloud flow (opens in a new tab)

The AI Hub is where you build generative AI prompts with prompt builder. A prompt is a task you give to a large language model, and you can start from a template or from a blank prompt.

What you need to know

• Reach prompt builder from AI hub > Prompts > Build your own prompt in Power Apps or Power Automate
• Start from blank, or pick a template from the prompt library, filtered by job type or task such as summarize, classify, or extract
• Write clear, specific instructions and test the prompt with sample values before you save
• AI Builder prompts run on GPT-4o and GPT-4o mini models powered by Azure OpenAI
• Prompts are reusable across Power Apps, Power Automate, and Copilot Studio

Microsoft Learn resource: Create a prompt (opens in a new tab)

Once a prompt is built, you can call it from a canvas app as a Power Fx function. This is how you add generative AI to an app without writing traditional code.

What you need to know

• Add the prompt from Data > Add data, then call it with .Predict() in a formula
• Pass the app's values as arguments and read the response, for example from result.text
• The prompt runs server-side and returns the generated text into your app
• Consuming a prompt works like consuming a custom AI model in an app
• The maker and users need the right AI Builder licensing and access to the prompt

Microsoft Learn resource: Use your prompt in Power Apps (opens in a new tab)

Prompts shine in automation, where a flow can run a prompt on incoming data and act on the result. This is how you build hands-off intelligent automation.

What you need to know

• Add the Run a prompt action to a cloud flow (it was renamed from Create text with GPT using a prompt in May 2025)
• Choose an existing prompt or create a new one, then fill its inputs with dynamic content
• The action outputs a Text variable you can use in later steps
• A common pattern is trigger, run a prompt, then post or store the result
• Keep a human in the loop for anything the generated text drives

Microsoft Learn resource: Use your prompt in Power Automate (opens in a new tab)

A grounded prompt answers using your business data rather than only the model's general knowledge. In prompt builder you add knowledge so responses are specific to your organization.

What you need to know

• Add a knowledge source, such as a Dataverse table, so the prompt can ground its answer in your data
• Grounding is what makes a prompt return answers about your records rather than generic text
• Knowledge is added in the same prompt builder view where you add inputs
• Grounded prompts are the basis of retrieval-style scenarios on your own data
• Combine knowledge with clear instructions for accurate, on-topic responses

Microsoft Learn resource: Add knowledge to your prompt (opens in a new tab)

Prompt builder lets you tune how the prompt behaves, including which model runs it. These settings trade off speed, cost, and quality.

What you need to know

• Choose the model that runs the prompt; options include GPT-4o and the faster, cheaper GPT-4o mini
• Adjust generation settings such as temperature to make output more focused or more varied
• Configure structured JSON output when a downstream step needs machine-readable data
• Test after changing settings, because model and temperature change the response
• Model availability varies by region, so check availability for your environment

Microsoft Learn resource: Change the model version and settings (opens in a new tab)

Inputs make a prompt dynamic by letting you pass values in at runtime. Without inputs, a prompt always runs on the same fixed text.

What you need to know

• Add an input by typing / or selecting Add content, then choose Text or Image or document
• Each input needs a sample value so you can test the prompt before using it
• At runtime, apps and flows fill the inputs with real values
• Image and document inputs let a prompt reason over files, not just text
• Reference inputs in the instructions so the model knows how to use them

Microsoft Learn resource: Add inputs to your prompt (opens in a new tab)

Beyond prompts, AI Builder offers prebuilt and custom models for tasks such as reading text, processing documents, and prediction. You can use these models directly in a canvas app.

What you need to know

• Prebuilt models are ready to use: text recognition (OCR), sentiment analysis, key phrase extraction, language detection, business card, receipt, and invoice processing
• Custom models are trained on your data for tasks such as document processing, object detection, and prediction
• Add a model to a canvas app and call it in a formula, similar to a prompt
• Prebuilt models need no training; custom models must be trained and published first
• Match the model type to the task; do not train a custom model when a prebuilt one already fits

Microsoft Learn resource: AI Builder in Power Apps overview (opens in a new tab)

AI models are just as useful in automation, where a flow can run a model on files or text as they arrive. Document and form processing are the classic examples.

What you need to know

• Add an AI Builder action to a flow to run a prebuilt or custom model
• Document and form processing extract fields from invoices, receipts, and custom forms
• The model's outputs become dynamic content for the next steps
• A common pattern is a file arrives, the model extracts data, and the flow writes it to Dataverse
• Custom models must be trained and published before a flow can use them

Microsoft Learn resource: AI Builder in Power Automate overview (opens in a new tab)

Business rules apply logic to a table without code, and because they run at the data level they work across every app that uses the table. This is the no-code way to enforce consistency.

What you need to know

• A business rule has conditions and actions such as set a value, set a default, set visibility, set requirement, lock or unlock, and show an error
• Scope decides where the rule runs: a specific form, all forms for the table, or Entity (server-side)
• An Entity-scoped rule runs everywhere the data is touched, including model-driven forms and server operations
• Business rules run on model-driven forms and, in a limited way, on canvas apps
• Use a business rule instead of a required column when you need real enforcement

Microsoft Learn resource: Create a business rule for a table (opens in a new tab)

A business process flow guides users through a consistent process, stage by stage, so everyone follows the same steps. It sits on top of your tables and can span several of them.

What you need to know

• A process flow is made of stages and steps, and it can span multiple tables
• It appears as a bar across the top of a model-driven form showing the current stage
• Steps can be required, so a user cannot advance until they are complete
• Business process flows are created in the Power Automate designer and stored as a Dataverse component
• Use them for repeatable processes such as lead to order or case resolution

Microsoft Learn resource: Business process flows overview (opens in a new tab)

Dataverse has three column types that compute their own value, and the exam expects you to tell them apart. Each recalculates differently, which is the key distinction.

What you need to know

• Rollups aggregate over one-to-many related rows, not many-to-many
• The default limit is 200 rollup columns per environment and 50 per table
• A manual online recalculation of a rollup is limited to 50,000 related rows

Exam tip: If a scenario needs an always-current total the instant a row changes, a rollup is the wrong choice because it recalculates on a schedule; consider a real-time approach instead.

Microsoft Learn resource: Automate calculations by defining calculated columns (opens in a new tab)

The last skill is judgment: given a requirement, pick the right place to put the logic. The exam rewards choosing the lightest tool that meets the need and knowing client-side from server-side.

What you need to know

• Business rules for no-code form and table logic that must apply everywhere
• Calculated, rollup, and formula columns for computed values stored on the row
• Business process flows for guiding users through stages
• Cloud flows for automation, integration, approvals, and anything cross-system
• Low-code plug-ins and Power Fx functions for reusable server-side logic, and pro-code plug-ins only when low-code cannot do it

Exam tip: Logic that must hold no matter which app touches the data belongs at the data level (Entity-scoped rules, columns, or plug-ins), not in a single app.

Microsoft Learn resource: Create relationships, business rules, calculations, and rollups in Dataverse (opens in a new tab)