Microsoft Certified: Intelligent Applications Builder Associate (AB-410) (AB-410) (AB-410) — Questions 1–75

Environment-based deployment isolates the updated flow in a separate Power Platform environment, letting testers validate changes without touching the production environment used by hundreds of employees. This directly satisfies the stem's constraint of testing updates without affecting the live version.

A rollup column aggregates values from related records in a one-to-many relationship, applying functions such as SUM across child expense rows. It stores the computed total cost on the parent project record, matching the stem's requirement for a derived sum of associated expenses.

Binding the save button's DisplayMode to Form.Valid disables it until every required field passes validation, enforcing the constraint at the control level without extra code or error-handling logic. This is the most efficient approach because Power Apps evaluates Form.Valid automatically as users edit fields.

A Topic in Copilot Studio defines trigger phrases and a conversation flow, so specific user questions route to the intended business logic. This gives deterministic, question-specific invocation rather than relying on generative orchestration to infer intent.

A synchronous plug-in on the Pre-Operation stage runs within the database transaction before the Order record is created. It can retrieve the related Account's CreditLimit and compare it to the Order total. If the limit is exceeded, it can throw an InvalidPluginExecutionException to cancel the operation. This ensures validation regardless of the data entry method, as all create operations trigger the plug-in.

System charts are a built-in chart type available in model-driven apps, configured against table data and rendered on dashboards or views. They are defined in the solution and available across the environment, unlike personal charts.

A lookup column creates a many-to-one relationship from the feedback table to the account table. It allows selecting a single account record and stores a reference to that record. This enforces referential integrity and enables navigation to the account from the feedback record. It is the standard way to associate a record with another table in Dataverse.

The 'Extract information from documents' action is specifically for AI Builder document processing models, including custom models trained to extract key-value pairs from forms and receipts. It accepts a document as input and returns the extracted fields as structured JSON. This directly meets the requirement to process scanned receipts and retrieve key-value pairs.

This uses a delegable Filter expression with a Dataverse connector. Dataverse supports delegation for comparison operators and the Today function in this context, so the filtering is performed server-side and returns complete, accurate results even when the table contains many records. Using Filter on the data source directly in Items is the recommended pattern for large Dataverse tables.

The AI Builder invoice processing action returns a 'Response' output that is a JSON object containing all extracted fields, such as invoice ID, date, total amount, and vendor name. You can use this dynamic content in subsequent actions, and parse it with Parse JSON to access individual fields. This is the correct way to retrieve structured data from the action.

coalesce returns the first non-null argument, so when the AI step's result is null it substitutes 'Unknown'. This satisfies the default-value requirement without branching logic, and also handles empty-string cases depending on the flow's evaluation.

Concurrency for Apply to each is configured in its settings, where you enable concurrency control and set the degree of parallelism. This satisfies the stem's requirement to process many rows concurrently, since the default runs iterations sequentially.

Tables are solution-aware Dataverse metadata, so they can be packaged, versioned and transported between environments as solution components. Including the table carries its columns, relationships and keys, satisfying the stem's requirement for a component that a Dataverse solution can contain.

A synchronous PreOperation plug-in on Update can compare the incoming received date to the pre-image value and throw InvalidPluginExecutionException if they differ, which cancels the transaction. This enforces immutability for every update path, including the Web API and flows, while leaving the inspection date freely editable. A calculated column can then compute elapsed days from the two dates.

Navigate can pass a context record to the target screen, and the detail screen reads it with a context reference. This is the standard way to carry the selected item's data forward without a separate lookup. Setting OnSelect on the gallery to Navigate with the selected record gives the detail screen exactly the data it needs.

The 'When a new email arrives (V3)' trigger in the Outlook connector is designed to fire when a new email is received. It supports specifying a shared mailbox by entering the mailbox address in the advanced options. This directly meets the requirement to trigger on new emails in a shared mailbox and provides the email body for further processing.

AI Builder's prompt builder lets makers author natural-language prompts grounded in a document input, then extract structured fields from it. This directly satisfies the requirement to create a prompt template that pulls information out of a document.

The Condition action evaluates an expression and branches execution. Comparing the model's score output to 0.8 with the greater() function and placing the Dataverse create action in the If yes branch ensures the record is created only when sentiment is strongly positive. This is the standard, efficient pattern for conditional logic in Power Automate.

Publishing promotes the current saved version of the app so that everyone it is shared with runs that build. Until Publish is clicked, edits remain in the authoring version only, so the constraint of delivering the latest changes to end users is met by this action.

Generative answers let Copilot retrieve and synthesise content from configured SharePoint knowledge sources, grounding responses in internal policy documents. This satisfies the stem's constraint of looking up company policies stored in a SharePoint site rather than relying on the model's pretrained knowledge.

Configuring generative answers with specific data sources restricts retrieval to the nominated company documents, grounding every response in that scoped content rather than open web knowledge. This directly satisfies the stem's constraint that the agent respond only from defined internal material, since the configured sources bound what the orchestration layer can retrieve and cite.

The 'less' function compares two values and returns true if the first is less than the second. Here, it checks if the confidence score is below 0.7, which is exactly the condition for routing to a human reviewer. This expression correctly uses the dynamic content reference for the AI Builder output and the threshold value.

The Icon property accepts a formula that evaluates the field's value and returns the matching icon name, so the displayed glyph changes dynamically per record. This satisfies the stem's requirement to show a specific icon based on a field value, rather than a static image set once at design time.

A parental relationship enforces cascade delete, so removing the project record automatically deletes all associated milestone records. This satisfies the stem's requirement that milestones be tied to a project and removed when that project is deleted, unlike a referential relationship with no cascade.

The custom connector's Security tab is where you define authentication, including API Key. The key is then provided when creating the connection, and it is stored securely by the platform, not in the app. This keeps the secret out of the app definition and out of user view, which is the correct approach.

Business Rules evaluate a condition on one column and then hide, show, set or validate fields without code, running client-side and server-side. This directly satisfies the stem's requirement to hide a field based on another field's value across forms.

Developer environments are a distinct Power Platform environment type, provisioned for individual makers to build and test without production licensing constraints. It satisfies the stem's requirement for a creatable environment type, differing from Production, Sandbox, Trial and Default in purpose and lifecycle.

AccessibleLabel supplies the text screen readers announce for a control, satisfying the accessibility requirement. Setting it on interactive controls and images gives non-visual users meaningful descriptions, unlike Tooltip, which is visual-only and not reliably read aloud.

Dataverse is provisioned automatically as the default database when a new environment is created, unless the maker explicitly selects an alternative such as SQL Server or the environment is created without a database. This satisfies the scenario's default database type requirement.

Desktop flows run attended or unattended on a Windows device via Power Automate for Desktop, giving the flow direct access to local applications, files and scripts. Cloud flows cannot execute code on a local machine, so a desktop flow is required to satisfy the on-premises execution constraint.

SortByColumns accepts a column name and a sort order, and both arguments are delegable against Dataverse. Supplying the sort order conditionally from the toggle lets the gallery re-sort reactively when the user flips it, satisfying the newest-first and oldest-first requirement with a single delegable expression.

Main forms are the primary full-page interface for creating and editing a table's records in model-driven apps, containing all configured columns, sections and tabs. They satisfy the requirement by serving as one of the two standard form types.

A View defines the filter criteria, columns and scope that determine which records a user sees. It satisfies the requirement by restricting the underlying object's records to those matching the specified criteria, without altering the stored data itself.

Dataverse combines privileges across multiple security roles additively, forming a union, so the granting role's access overrides the restricting role's denial. This satisfies the scenario: the user sees records because no role subtracts privileges from another.

Delegable filters push the date range predicate to SQL Server, so only matching rows return to the app. This keeps the app responsive as the table grows and avoids the non-delegable warning that truncates results at the delegation limit, which is essential when the table is large.

Scopes group actions into Try and Catch blocks, so a failure inside the Try scope is caught and handled by the Catch scope's actions. This satisfies the advanced error-handling requirement by centralising failure logic instead of configuring conditions on every individual action.

Record-level security in Dataverse is enforced through security roles and access levels. By setting the access level to 'User' or 'Business Unit', you can restrict users to only see records they own or that are shared with them. This directly addresses the requirement to control record visibility based on ownership.

The System message field carries the persona instruction that shapes the model's behaviour across the conversation. Defining the technical support agent role there sets the model's context and tone, satisfying the requirement to establish the persona before user prompts are processed.

Sharing with security groups satisfies the requirement to grant access to multiple users simultaneously. Microsoft Entra ID security groups centralise permission management, so membership changes automatically propagate app access without editing individual shares. This scales cleanly for teams, unlike per-user sharing, and remains the supported method for canvas app distribution.

After enabling table auditing, you must also enable auditing on each individual column that you want to track. Dataverse does not audit all columns by default; only those explicitly enabled will have changes recorded. This allows granular control over what is audited.

Set creates a global variable that persists for the app session and is visible on every screen. Storing the selected record in a global variable lets the detail screen read it directly via the variable name, avoiding a second query to Dataverse. This is the standard pattern for passing a record between screens without duplicating data access.

The Preview button (play icon) runs the canvas app inside Power Apps Studio, letting makers interact with screens, formulas and controls in a live session without publishing, so testing occurs before any version reaches users.

Text() converts a numeric value into a formatted string, and its format argument accepts named patterns such as "[$-en-GB]#,##0.00" to render currency. This satisfies the requirement to display a number as currency within a canvas app label.

Parental behavior in a one-to-many relationship means that when the parent record (Table A) is deleted, all child records (Table B) are also deleted. This cascading delete matches the requirement. It also allows for cascading assignment and sharing, but the key here is the cascade delete.

Create text with GPT using a prompt sends the email body into a custom prompt and returns the model's generated summary. It is the AI Hub action that accepts prompt input and produces text output, satisfying the requirement to pass email content to the custom prompt.

Clicking the specific iteration in the Run history exposes that iteration's own inputs and outputs, which satisfies the requirement to inspect a single loop iteration within a large array. Power Automate records each iteration as a discrete entry, so the per-iteration detail view isolates the exact data you need.

This is the standard pattern: a cloud flow triggered by Power Apps (V2) exposes a Run method in the canvas app. The app passes the order details as parameters, and the flow sends the email. This reuses the flow, keeps logic centralized, and requires no custom code.

AI Builder returns confidence scores for extracted fields. A 'Condition' action can evaluate the score against a threshold. If confidence is low, routing to an approval ensures a human validates the data before it is committed to Dataverse, maintaining data quality. The flow can then use the approval outcome to decide whether to write the record and trigger the canvas app, providing a controlled exception path.

Training with diverse samples improves the model's ability to generalize across layout variations. AI Builder document processing learns from the provided examples, so including different formats helps it recognize fields regardless of layout. This is the recommended practice before using the model in a flow for high-volume processing.

Switch is ideal for multi-value branching based on AI outputs.

Setting a column as Required or Optional is a configurable property in Dataverse, directly satisfying the stem's demand for configurable column properties. This setting controls whether users must supply a value when creating or updating records, enforcing data integrity at the table level without custom code.

The Business Unit access level restricts a user to records owned by their own business unit and its children, matching the requirement that users see only their unit's records. It is more restrictive than Parent: Child Business Units and Organisation, which grant broader visibility.

Visible is a Boolean property that determines whether a control renders on the canvas at all. Toggling it hides or shows the control without deleting it, which is a display behaviour rather than a data or action property, so it belongs among the properties governing a control's visual appearance.

Intent-based routing dispatches a query to the most appropriate agent, a core orchestration pattern where a coordinator selects among specialised agents. It contrasts with single-agent execution, which handles a request directly without delegation or selection logic.

App Checker scans a model-driven app's configuration and reports errors and warnings, such as invalid component references or missing dependencies. This satisfies the requirement by giving makers a consolidated diagnostic view before publishing, rather than discovering faults at runtime.

A scheduled trigger runs the flow automatically on a recurring recurrence, such as daily at 09:00, with no user or event input. This satisfies automation scenarios requiring predictable, time-based execution rather than manual or event-driven initiation.

Relationship type defines the cardinality between the two tables, letting you choose one-to-many or many-to-many. This directly satisfies the stem's requirement for a configurable table relationship item, since cardinality is a core property set when defining how records in one table associate with records in another.

Alternate keys in Dataverse enforce uniqueness on one or more columns at the platform level. When an alternate key is defined on the project code column, any attempt to create or update a record with a duplicate code will be rejected server-side, regardless of the client. This meets the requirement for server-side uniqueness enforcement.

Table extraction depends on diverse, representative examples. If the training set lacks variation in column order, row counts, and table styling, the model cannot generalize. Adding labeled samples with different table structures directly addresses the gap and is the recommended first step before changing model type or increasing sample count blindly.

Copilot in Power Automate accepts conversational instructions, so describing the desired change in natural language regenerates or adjusts the flow's actions and connections. This is the supported refinement mechanism; manual editing of the underlying definition bypasses Copilot entirely.

A local variable acting as a re-entrancy guard blocks the second click because the flag is set synchronously before the SubmitForm call begins. Resetting the flag in OnSuccess restores normal behavior after the save completes, preventing duplicates without permanently disabling the button or altering the form's standard submission flow.

Secure Outputs prevents the action's outputs from being logged in the run history. This is the correct approach to hide AI-generated content from logs, meeting compliance requirements. It does not affect the action's functionality but ensures sensitive data is not persisted.

Business rules run client-side on the form and can set field visibility based on another column's value, so the field appears only when the choice column equals the specified option. This satisfies the conditional display requirement without JavaScript or form scripting.

Chunking splits the oversized input into smaller segments that each fit within the prompt's token ceiling, directly resolving the token-limit exceed. Sending the data in sequential batches lets every portion be processed without truncation, satisfying the constraint that the full input cannot be submitted in a single prompt call.

Date and Time with Time Zone stores the date, time, and the time zone offset in which it was entered. This is the only Dataverse data type that preserves the original time zone offset. It is ideal for scenarios where the exact moment and the originating time zone matter, such as feedback submission from different regions.

The run history records each action's inputs, outputs and error codes, so it pinpoints the exact failing step and its message. Inspecting it satisfies the stem's need to identify the root cause rather than merely confirming the flow failed.

IfError allows you to handle errors gracefully when submitting data. It can catch issues like network failures or validation errors from Dataverse, enabling you to display user-friendly messages. This is a best practice for robust data operations in canvas apps, ensuring users are informed and can retry.

Filtering at the source reduces the number of items retrieved, and enabling concurrency in 'Apply to each' allows parallel processing of iterations, improving throughput. This combination is the recommended way to handle large batches efficiently while staying within service limits. It also reduces the risk of throttling.

App Checker scans a canvas app's formulas and configuration, surfacing errors, warnings and delegation issues in a side pane. This satisfies the stem's purpose directly: it identifies problems such as unsupported functions or inefficient queries before publishing, rather than monitoring runtime performance or governing environments.

A cloud flow runs server-side, so the Azure OpenAI connection and its key are stored in the connection, never in the client. Adding the flow to the canvas app lets the app call the model through the flow's Run method, keeping credentials secure while returning the summary to the app.

Large, touch-friendly controls increase tap targets to suit finger input rather than a mouse pointer, directly addressing the mobile usability constraint in the stem. Adequate sizing reduces mis-taps on small screens, which fixed desktop-sized controls cannot achieve.

Evaluating model performance quantifies accuracy, precision, recall or similar metrics against held-out data, confirming the custom model meets its intended task before release. This verification step is essential in the preparation lifecycle, satisfying the stem's requirement for a necessary custom AI model activity.

Knowledge sources ground the Copilot in authoritative organisational content such as SharePoint sites and websites, so answers derive from verified material rather than model guesswork. This directly satisfies the requirement for accurate, relevant responses within the defined scope.

A one-to-many relationship from Project to Task correctly models the requirement: one project can have many tasks, and each task is linked to one project. This relationship type creates a lookup column on the Task table pointing to Project, establishing the referential link needed for the cascade behavior.

Data source configuration determines how Power Apps connects, authenticates and retrieves records, directly affecting delegation limits and round-trip latency. Choosing appropriate connectors, views and delegation-capable sources satisfies the stem's performance requirement by reducing client-side processing and unnecessary data transfer.