Courseiva

CCNA Building The Apps Questions

75 of 83 questions · Page 1/2 · Building The Apps topic · Answers revealed

1
MCQhard

You need to ensure that a canvas app user can only save their changes if all required fields are filled. What is the most efficient way to validate this?

A.Set the button DisplayMode based on Form.Valid
B.Use a timer
C.Use a variable
D.Write a manual check for each field
AnswerA

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.

Why this answer

In Power Apps canvas apps, the Form control exposes a Valid property that is true only when all required fields are filled and all validation rules pass. Binding the submit button's DisplayMode to If(Form1.Valid, DisplayMode.Edit, DisplayMode.Disabled) prevents saving until the form is valid, which is the most efficient built-in approach. This leverages the form's own validation engine instead of duplicating logic.

Exam trap

AB-410 often tests whether candidates overcomplicate validation with variables or timers instead of using the Form control's built-in Valid property.

How to eliminate wrong answers

Option B is wrong because a timer cannot evaluate field validity and would not prevent invalid saves. Option C is wrong because a variable alone does not automatically track form validity unless it is updated by validation logic, which is redundant. Option D is wrong because manually checking each field duplicates the form's built-in validation, increases maintenance, and is error-prone.

2
MCQmedium

You are building a canvas app that connects to a Microsoft Dataverse table named Project Tasks. The app needs to display only tasks where the Status column equals Active and the Due Date is within the next 30 days. You must implement this filtering in a way that delegates to Dataverse and returns accurate results regardless of table size. Which approach should you use?

A.Add a filter to the Dataverse view associated with the table and rely on the app to automatically apply it when the gallery loads.
B.Load all rows into a collection on OnStart using ClearCollect, then filter the collection in the gallery Items property.
C.Set the gallery Items property to Filter('Project Tasks', Status = 'Active' && 'Due Date' <= Today() + 30).
D.Use the Search function in the gallery Items property with a text string matching the Status and Due Date values.
AnswerC

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.

Why this answer

The correct approach is to write a delegable Filter expression directly against the Dataverse table in the gallery Items property. Dataverse supports delegation for equality and date comparisons, so the server performs the filtering and returns all matching rows. This avoids row-limit issues and ensures the app shows accurate data regardless of table size.

Exam trap

The trap here is assuming that preloading data into a collection makes filtering faster or more reliable, when it actually inherits the connector's row limit and can silently omit records.

3
MCQeasy

You are creating a canvas app that must display a list of customers from a Dataverse table. Users need to tap a customer to open a detail screen showing that customer's full record. Which property should you configure to pass the selected customer to the detail screen?

A.Set the gallery's OnSelect property to Navigate with a context variable containing the selected record.
B.Bind the detail screen's form to the gallery's Items property.
C.Create a global variable with Set in the App.OnStart property and update it when a customer is tapped.
D.Set the gallery's Default property to the selected record so the detail screen inherits it.
AnswerA

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.

Why this answer

To show a single selected record on a detail screen, the gallery's OnSelect should call Navigate and pass the selected item as a context record. The detail screen then references that context variable in its form or labels. This is the standard navigation pattern for master-detail layouts in canvas apps.

Exam trap

The trap here is confusing control properties like Default with navigation, when passing records between screens is done through Navigate and context variables.

4
MCQeasy

What is the purpose of the 'Publish' button in the Power Apps Studio?

A.To share the app with new users
B.To save your work to the cloud
C.To debug the app
D.To make the latest version available to users
AnswerD

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.

Why this answer

The Publish button in Power Apps Studio takes the current saved version of the app and makes it the live version that end users will see when they open the app. Until you publish, changes remain in your editing session and are not visible to consumers, even if you have saved. This is distinct from saving (which persists your work) and sharing (which controls who can access the app).

Exam trap

The trap here is conflating Save with Publish — candidates assume that saving automatically makes changes live, but Power Apps deliberately separates authoring persistence from runtime availability.

How to eliminate wrong answers

Option A is wrong because sharing is done through the Share menu, where you grant users or groups access to the app — Publish does not change permissions. Option B is wrong because saving your work is handled by the Save/Save As commands, which persist the app definition to the environment; Publish is a separate step that promotes the saved version to production. Option C is wrong because debugging is done through the Monitor tool or the App Checker, not the Publish button.

5
MCQeasy

Which property must you configure in a canvas app to show a specific icon based on the value of a field?

A.Fill property
B.DisplayMode property
C.Icon property
D.Visible property
AnswerC

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.

Why this answer

The Icon property on an icon control determines which glyph is rendered, so binding it to a conditional expression based on a field value lets the icon change dynamically. For example, setting Icon to If(ThisItem.Status = "Open", Icon.Warning, Icon.Check) displays different symbols per record. This is the property that directly controls the visual symbol, not the control's visibility or fill.

Exam trap

The trap here is confusing visual styling properties (Fill, Visible, DisplayMode) with the property that actually selects the glyph, causing candidates to pick a property that changes appearance but not the icon itself.

How to eliminate wrong answers

Option A is wrong because the Fill property controls the background color of the control, not which icon glyph is displayed. Option B is wrong because DisplayMode controls whether the control is editable, view-only, or disabled, not the icon shown. Option D is wrong because Visible only toggles whether the control is rendered at all, not which icon appears.

6
MCQhard

You are developing a canvas app that calls a custom connector to retrieve inventory data from an external REST API. The API requires an API key. You need to store the key so the app can use it without exposing it to users or embedding it in the app. Where should you configure the API key?

A.In the custom connector's Security tab, using API Key authentication.
B.In a Microsoft Dataverse table with column-level security enabled.
C.In a global variable set in the App's OnStart property.
D.In the app's Settings under Support, as an environment variable.
AnswerA

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.

Why this answer

Custom connectors define their authentication on the Security tab. Selecting API Key lets the platform prompt for the key when a connection is created and store it securely. The app then references the connection, so the secret never appears in the app's formulas or settings, which prevents exposure to users and app editors.

Exam trap

The trap here is thinking that a global variable or app setting can securely hold a secret, when connector authentication is the intended secure mechanism.

7
MCQmedium

You want to make sure your canvas app is accessible. Which property should you configure for screen readers?

A.DisplayMode
B.Tooltip
C.AccessibleLabel
D.Text
AnswerC

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.

Why this answer

AccessibleLabel is the property in Power Apps canvas apps that provides a text description for screen readers, allowing visually impaired users to understand the purpose of a control. It is specifically designed for accessibility and is read aloud by assistive technologies.

Exam trap

The trap is confusing Tooltip with AccessibleLabel — candidates often think tooltips help screen readers, but only AccessibleLabel is explicitly designed for assistive technologies.

How to eliminate wrong answers

Option A (DisplayMode) is wrong because it controls whether a control is editable, view-only, or disabled — it has no role in screen reader accessibility. Option B (Tooltip) is wrong because tooltips appear on hover and are not reliably read by screen readers; they are a visual aid, not an accessibility label. Option D (Text) is wrong because the Text property sets the visible text of a control, but screen readers may not interpret it as a label for the control's purpose, especially for non-text controls like icons or images.

8
MCQmedium

You are building a canvas app that must display a gallery of Dataverse records sorted by a date column, and users can switch the sort order between newest-first and oldest-first via a toggle. Which approach correctly implements this requirement?

A.Set the gallery Items to Sort(Project, CreatedOn, If(tglNewest.Value, Descending, Ascending)).
B.Set the gallery Items to SortByColumns(Project, "CreatedOn", If(tglNewest.Value, SortOrder.Descending, SortOrder.Ascending)).
C.Set the gallery Items to Filter(Project, CreatedOn >= tglNewest.Value).
D.Set the gallery Items to FirstN(SortByColumns(Project, "CreatedOn"), 100).
AnswerB

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.

Why this answer

SortByColumns is the delegable way to order Dataverse records by a named column, and its sort-order argument can be supplied conditionally from a toggle. Because the expression references the toggle's value, the gallery re-sorts automatically when the user switches between newest-first and oldest-first. Non-delegable Sort, truncated FirstN results, and Filter-based expressions either return incomplete data or do not sort at all.

Exam trap

The trap here is reaching for the Sort function with a formula, which looks equivalent but is not delegable and can silently drop rows from the gallery.

9
Multi-Selecthard

You are designing a canvas app that connects to an on-premises SQL Server through the on-premises data gateway. The app must filter a large table by a date range and remain performant. Which TWO practices should you follow? (Choose two.)

Select 2 answers
A.Disable the on-premises data gateway and connect to SQL Server directly from the app.
B.Set the app's data row limit to the maximum value so all rows are available for client-side filtering.
C.Load the entire table into a collection on app start and filter the collection locally in memory.
D.Use delegable filter functions such as Filter with comparison operators on the date column so the query is executed server-side.
E.Limit the columns returned by selecting only the fields the app needs rather than the full record set.
AnswersD, E

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.

Why this answer

Delegable filters and column projection are the two practices that keep a gateway-backed canvas app performant. Delegation ensures the date range predicate runs in SQL Server, and projecting only the needed columns reduces the data crossing the gateway. Together they minimize payload size and avoid the delegation limit that silently truncates results.

Exam trap

The trap here is treating the data row limit as a performance knob, when raising it actually pulls more rows to the client and hides delegation problems instead of solving them.

10
Multi-Selecteasy

Which TWO methods can you use to share a canvas app with other users?

Select 2 answers
A.By saving to a local disk
B.Sharing with security groups
C.Sharing via email link (without permission)
D.Publicly on the internet
E.Sharing with individual users
AnswersB, E

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.

Why this answer

In Power Apps, canvas apps are shared from the app's Share screen, where you can grant access to individual users (option E) by entering their names or email addresses and assigning them either the User or Co-owner role, which is the standard way to give specific people access. Option B is also correct because the same Share dialog lets you add Azure Active Directory security groups, so every member of the group inherits the app permissions, which is the recommended approach for scaling access to teams or departments. Options A, C, and D are not valid sharing methods: saving to a local disk (A) only produces a local .msapp file that cannot be run by others without importing it into their own environment, sharing via an email link without permission (C) does not exist because recipients must still be granted access in the app's user list, and publishing publicly on the internet (D) is not supported for canvas apps, which always require authenticated access through the Power Apps service.

Exam trap

AB-410 often tests the misconception that a link alone grants access — candidates forget that Power Apps sharing always requires an explicit permission assignment to a user or group.

11
MCQeasy

You are assembling a canvas app screen that lists customers and lets users drill into a detail view. You want the selected customer's record to be available to a second screen without re-querying Dataverse. Which Power Fx construct should you use to pass the record between screens?

A.Store the record in a collection with Collect and read it from the detail screen's gallery.
B.Store the record in a named formula with a parameter and evaluate it on the detail screen.
C.Store the record in a global variable with Set and reference it on the detail screen.
D.Store the record in a context variable with UpdateContext on the first screen and read it on the second.
AnswerC

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.

Why this answer

Global variables created with Set persist across every screen for the duration of the app session, so a record captured on the list screen remains readable on the detail screen. This avoids a redundant Dataverse query. Context variables are limited to one screen, collections carry unnecessary multi-row overhead, and named formulas cannot be parameterized at runtime.

Exam trap

The trap here is confusing context variables, which are screen-scoped, with global variables, which survive navigation between screens.

12
MCQeasy

Which tool in the Power Apps environment allows you to test your canvas app without publishing it?

A.Publish button
B.App checker
C.Data pane
D.Preview button
AnswerD

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.

Why this answer

The Preview button (or F5) runs the canvas app in a preview/play mode so you can test its behavior and interactions without publishing it to users. This lets makers validate functionality, formulas, and navigation in a safe environment. Publishing is a separate step that distributes the app to end users.

Exam trap

The trap is confusing App checker (static analysis) with Preview (runtime testing) — candidates may pick App checker thinking it 'tests' the app, but it only scans for issues without running it.

How to eliminate wrong answers

Option A is wrong because the Publish button makes the app available to users — it is the opposite of testing without publishing. Option B is wrong because App checker is a static analysis tool that scans for formula errors, accessibility issues, and performance problems; it does not run the app for interactive testing. Option C is wrong because the Data pane is for managing data sources and their fields, not for executing or testing the app.

13
MCQmedium

You need to format a number as currency in a canvas app label. Which function should you use?

A.Format()
B.Value()
C.Text()
D.Currency()
AnswerC

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.

Why this answer

The Text() function in Power Apps is specifically designed to convert a value to a string with optional formatting, including currency. It accepts a format string such as "$#,##0.00" or a predefined format like "[$-en-US]$#,##0.00". This makes it the correct choice for displaying a number as currency in a label.

Format() is not a Power Apps function, Value() converts text to a number, and Currency() is not a function in Power Apps.

Exam trap

AB-410 often tests the confusion between Text() and Value() functions, where candidates might think Value() formats numbers, but it actually parses text into numbers, and they might also mistakenly believe Format() or Currency() exist in Power Apps.

How to eliminate wrong answers

Option A is wrong because Format() is not a valid Power Apps function; it is commonly confused with the Text() function or with functions in other languages like Excel. Option B is wrong because Value() does the opposite: it converts a text string to a number, not a number to a formatted currency string. Option D is wrong because Currency() is not a function in Power Apps; while there is a data type for currency, there is no built-in function with that name for formatting.

14
Multi-Selectmedium

Which THREE properties are commonly used to control the visual appearance of a control in a canvas app?

Select 3 answers
A.Visible
B.BorderColor
C.OnSelect
D.Fill
E.DataSource
AnswersA, B, D

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.

Why this answer

Visible (A) is a standard property that controls whether a control is shown or hidden, directly affecting its visual appearance in the app. BorderColor (B) sets the color of a control's border, which is a purely visual styling property. Fill (D) defines the background color of a control, another core visual appearance property.

OnSelect (C) is incorrect because it defines behavior (an action triggered when the control is selected), not visual appearance. DataSource (E) is incorrect because it specifies the data connection for a control, which relates to data, not visual styling.

Exam trap

The trap is mixing property categories — candidates see familiar property names like `OnSelect` and `DataSource` and forget the question specifically asks about visual appearance, not behavior or data binding.

15
MCQhard

You are building a canvas app that submits new rows to a Microsoft Dataverse table from a form. Users report that duplicate rows appear when they click Save twice quickly. You must prevent duplicate submissions while preserving the form's normal submit behavior. What should you do?

A.Set the form's OnSuccess property to call ResetForm and set the button's OnSelect to Notify with a success message.
B.Wrap the SubmitForm call in an If statement that checks a local variable flag, sets the flag before SubmitForm, and resets it in the form's OnSuccess property.
C.Set the SubmitForm button's DisplayMode to Disabled when the form's Unsaved property is false.
D.Add a unique constraint on the Dataverse table and rely on the error returned by SubmitForm to block the duplicate.
AnswerB

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.

Why this answer

Guarding SubmitForm with a local variable that is set before the call and cleared in OnSuccess prevents the second rapid click from starting another submission. The flag is evaluated synchronously in the button's OnSelect, so the second event sees it as true and skips the submit. Resetting in OnSuccess keeps the button usable for the next record.

Exam trap

The trap here is believing that disabling the button or adding a database constraint eliminates the race, when only a synchronous guard in the click handler prevents the second submit from starting.

16
MCQhard

You are configuring a model-driven app form. You need to show a field only if a choice column has a specific value. What should you use?

A.Workflow
B.Power Fx formula in the field property
C.Canvas component
D.Business rule
AnswerD

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.

Why this answer

Business rules in model-driven apps are the correct mechanism to conditionally show, hide, enable, disable, or set values on fields based on other column values, without writing code. They run on the client (form) and optionally server-side, and are configured declaratively in the Power Apps maker portal. A business rule can evaluate a choice column and set the visibility of another field accordingly, satisfying the requirement directly.

Exam trap

AB-410 often tests the confusion between business rules (model-driven, declarative, form-level) and Power Fx (canvas apps), so candidates must match the tool to the app type.

How to eliminate wrong answers

Option A is wrong because a workflow (classic or Power Automate) runs asynchronously or on-demand and cannot dynamically control form field visibility in real time as the user interacts with the form. Option B is wrong because Power Fx formulas in field properties are used in canvas apps, not model-driven app forms, which use the form designer and business rules instead. Option C is wrong because a canvas component is a reusable UI element for canvas apps and has no role in model-driven form field visibility logic.

17
Multi-Selecthard

You are building a canvas app that uses a Microsoft Dataverse table named Orders. The app must allow users to create new orders and update existing ones. You need to ensure that the app handles data validation and error handling properly. Which two actions should you perform? (Choose two.)

Select 2 answers
A.Use the IfError function to catch errors when submitting data with the SubmitForm function.
B.Enable the 'Data validation' option in the app settings to automatically validate all forms.
C.Set the Required property on input controls to ensure users cannot submit empty fields.
D.Use the Patch function to update records and rely on Dataverse to automatically validate all fields.
E.Use the Collect function to save data to a local collection and then sync to Dataverse later.
AnswersA, C

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.

Why this answer

To handle data validation and error handling properly, you should use IfError with SubmitForm to catch and manage errors during data submission, and set the Required property on input controls for client-side validation. These two actions together provide a robust solution that prevents invalid data submission and gracefully handles errors, ensuring a smooth user experience.

Exam trap

The trap here is assuming that Dataverse automatically handles all validation and error handling without any app-level configuration, or that a global setting can enable validation across all forms.

18
MCQeasy

What is the purpose of the App Checker in Power Apps?

A.To publish the app
B.To identify errors and warnings
C.To share the app
D.To create new tables
AnswerB

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.

Why this answer

The App Checker in Power Apps is a built-in tool that scans the app for errors, warnings, and best-practice issues (like delegation problems, accessibility issues, and unused variables). It surfaces these in a panel so makers can fix them before publishing. Its purpose is diagnostic, not deployment or sharing.

Exam trap

AB-410 often tests the distinction between App Checker (diagnostics) and other maker tools like Publish, Share, and Solution Explorer — candidates pick 'publish' because App Checker is often run right before publishing.

How to eliminate wrong answers

Option A is wrong because publishing the app is done via the Save/Publish command, not the App Checker. Option C is wrong because sharing the app is handled through the Share dialog, which manages user and group permissions. Option D is wrong because creating tables is done in Dataverse (via the maker portal or solution explorer), not in the App Checker.

19
MCQmedium

A team is building an intelligent app that summarizes customer emails using an Azure OpenAI model. The model call must be made from a Power Apps canvas app, and the API key must never be exposed in the client. Which approach should the team use?

A.Store the API key in a canvas app variable initialized in the App OnStart property and pass it in the request header.
B.Use the Azure OpenAI connector directly in the canvas app and rely on the connector's built-in key management.
C.Create a Power Automate cloud flow that calls the Azure OpenAI connector, add the flow to the canvas app, and invoke it from the app.
D.Call the Azure OpenAI REST endpoint directly from the canvas app using the Office 365 Users connector to authenticate.
AnswerC

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.

Why this answer

Routing the model call through a Power Automate cloud flow keeps the Azure OpenAI connection and its API key server-side in the connection, so the canvas app only invokes the flow. This prevents credential exposure in the client while still returning the model's summary to the app.

Exam trap

The trap here is assuming a canvas app can safely hold a secret in a variable or call the model directly, when any client-side value can be extracted.

20
Multi-Selecthard

Which TWO ways can you optimize a canvas app for mobile users?

Select 2 answers
A.Add a high-resolution video background
B.Use large, touch-friendly controls
C.Increase the number of columns
D.Enable responsive layout settings
E.Use a mouse-hover trigger
AnswersB, D

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.

Why this answer

Option B is correct because large, touch-friendly controls sized for finger input (typically at least 40x40 pixels with adequate spacing) reduce mistaps and improve usability on small mobile touchscreens. Option D is correct because enabling responsive layout settings in Power Apps (such as the 'Scale to fit' and 'Lock aspect ratio' settings, or using containers with flexible height/width) lets the app adapt to different screen sizes and orientations on phones and tablets. Option A is not appropriate because a high-resolution video background increases load time and bandwidth consumption, hurting performance on mobile networks.

Option C is wrong because increasing the number of columns crowds the limited screen width and makes content harder to read and interact with on a phone. Option E is incorrect because mouse-hover triggers do not exist on touch devices, so that interaction would be unusable for mobile users.

Exam trap

The trap is selecting options that sound visually appealing (like video backgrounds) but actually degrade mobile performance, or forgetting that hover interactions are desktop-only.

21
Multi-Selecthard

Which TWO properties are most important for data performance in a canvas app?

Select 2 answers
A.App font size
B.Control border color
C.Background image opacity
D.Data source configuration
E.Items property filtering
AnswersD, E

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.

Why this answer

Option D, data source configuration, is correct because how a data source is set up (for example, using delegable connectors like SQL Server or Dataverse versus non-delegable ones, and limiting the columns/rows retrieved) directly determines how much data is pulled to the client and whether queries can be processed server-side, which is the primary driver of canvas app data performance. Option E, Items property filtering, is correct because applying filters in the Items property (ideally with delegable functions such as Filter, and avoiding non-delegable constructs) reduces the volume of records loaded and rendered, so the app retrieves only the needed subset rather than the entire data set. The remaining options do not belong: A (app font size), B (control border color), and C (background image opacity) are purely cosmetic UI styling properties that have no meaningful effect on how data is queried, transferred, or processed, and thus do not impact data performance.

Exam trap

AB-410 often tests whether candidates confuse visual properties with performance-related properties, leading them to pick font size or colors instead of data source configuration and Items filtering.

22
MCQmedium

You are building a canvas app that lets a customer service agent edit a case. The agent must not be able to save the case until the Resolution notes field contains at least twenty characters, and the Save button should visibly indicate when the form is invalid. Which configuration should you use?

A.Add a Rule to the form's Valid property that requires the Resolution notes field.
B.Use Notify("Resolution too short", NotificationType.Error) in the Save button's OnSelect and exit the formula.
C.Set the Save button's DisplayMode to If(Len(ResolutionNotes.Text) >= 20, DisplayMode.Edit, DisplayMode.Disabled).
D.Set the Resolution notes text input's Required property to true and the Format property to Text.
AnswerC

Binding the Save button's DisplayMode to a length check on the text input makes the button disabled and visually greyed out until the notes reach twenty characters. This satisfies both requirements with one formula: the agent cannot save prematurely, and the disabled appearance communicates the invalid state clearly. It is the standard canvas app validation pattern for this scenario.

Why this answer

Canvas app validation is typically implemented by binding the Save button's DisplayMode to the validity condition. A formula that checks the length of the Resolution notes input and returns DisplayMode.Edit only when the threshold is met both blocks the save and greys out the button, giving the agent immediate visual feedback. Required properties and notification calls do not enforce a minimum character count or provide the same proactive visual cue.

Exam trap

The trap here is thinking that the form's Valid property or a Required toggle can enforce a minimum character count when they only check for presence.

23
Multi-Selectmedium

Which THREE tools are available in the Power Apps maker portal?

Select 3 answers
A.Solution explorer
B.Data designer
C.Physical server rack management
D.C++ compiler
E.App designer
AnswersA, B, E

Solution explorer is a core Power Apps maker portal tool, letting makers create, manage and export solutions that package apps, flows, tables and other components for transport between environments. It directly satisfies the question's requirement for tools available within the maker portal itself.

Why this answer

The Power Apps maker portal (make.powerapps.com) provides a Solution explorer, which is the interface for creating and managing solutions that package apps, flows, tables, and other components for ALM and transport between environments, so option A is correct. It also includes a Data designer, used to create and edit Microsoft Dataverse tables, columns, and relationships directly within the maker experience, making option B correct. The App designer (canvas app studio) is likewise available in the maker portal for building canvas apps with screens, controls, and formulas, so option E is correct.

Options C and D are incorrect because physical server rack management is a datacenter/hardware concern unrelated to Power Apps, and a C++ compiler is a software development tool not offered in the Power Apps maker portal.

Exam trap

AB-410 often tests whether candidates confuse the maker portal with admin center or with unrelated developer tooling, so distractors like compilers or hardware management are inserted to catch superficial readers.

24
MCQeasy

A team is building a canvas app that calls a Power Automate cloud flow to create a record in Dataverse when a user selects a button. The flow runs but returns no data back to the app, and the app's label never updates. You confirm the flow completes successfully and returns a response. What should you verify in the app to ensure the returned value is displayed?

A.That the flow's Run only when condition is set to true
B.That the label's Text property references the flow's response output
C.That the button's OnSelect property uses a Collect function
D.That the app has the Dataverse connector added
AnswerB

When a canvas app calls a Power Automate flow, the returned values are accessed through the flow's output object, and a control must explicitly bind to that output to show the data. If the label's Text property is not set to the flow response property, the label stays blank even though the flow succeeded. Verifying and correcting that binding is the action that makes the returned value appear.

Why this answer

A canvas app retrieves values from a Power Automate flow through the flow's output object, and any control that should display that data must bind to it. Because the flow already runs and returns a response, the remaining step is ensuring the label's Text property references that response output. The other checks concern flow triggering, direct Dataverse access, or local collections, none of which affect displaying the returned value.

Exam trap

The trap here is assuming that a successful flow automatically pushes its data into the app, when the app must explicitly reference the flow's output in a control property.

25
MCQmedium

You are building a canvas app and need to filter a gallery based on a text input search. What is the best function to use?

A.LookUp()
B.Sort()
C.Search()
D.Filter()
AnswerC

Search() matches a substring within a specified column and returns results, making it ideal for free-text gallery filtering. Unlike Filter(), which requires exact or StartsWith comparisons, Search() handles partial matches anywhere in the field, satisfying the text-input search requirement.

Why this answer

The Search() function is specifically designed for text-based filtering in Power Apps. It searches a table for records where a specified column contains a given text string, ignoring case. Unlike Filter(), which requires a full expression and does not automatically handle partial matches, Search() simplifies the process by directly checking if the column value contains the search term.

This makes it the best choice for a gallery filter based on a text input search.

Exam trap

AB-410 often tests the confusion between Search() and Filter(), where candidates assume Filter() is always the go-to for text search, but Search() is specifically optimized for simple text containment and case-insensitive matching.

How to eliminate wrong answers

Option A is wrong because LookUp() returns only the first record that matches a condition, not a filtered table for a gallery. Option B is wrong because Sort() orders records but does not filter them based on search criteria. Option D is wrong because Filter() can achieve similar results but requires a more complex expression (e.g., using the 'in' operator or StartsWith) and does not automatically perform case-insensitive partial matching like Search() does.

26
MCQhard

A developer is creating a custom connector for a REST API that requires an API key in the header. The connector will be used in a canvas app. The developer wants to ensure that the API key is not exposed to users of the app. What should the developer do?

A.Ask users to enter the API key in the app, and store it in a collection.
B.Configure the connector's security to use API Key authentication.
C.Hardcode the API key in the connector's Swagger definition.
D.Store the API key in a Power Apps environment variable and reference it in the connector.
AnswerB

Custom connectors support API Key authentication as a security option. When configured, the API key is stored securely in the connector's settings and is not exposed to app users. The connector handles the key injection at runtime. This is the correct way to protect the key while allowing the app to call the API.

Why this answer

The secure way to use an API key in a custom connector is to configure the connector's security settings to use API Key authentication. The key is then stored securely and injected by the connector at runtime, so app users never see it. Hardcoding, using environment variables, or asking users for the key are insecure and expose the secret.

Exam trap

The trap here is thinking that environment variables or user input are secure places for secrets, when connector security settings are the proper location.

27
MCQmedium

You are creating a custom page for a model-driven app. What is the primary benefit of using custom pages?

A.To bypass security roles
B.To improve database performance
C.To replace all forms
D.To combine canvas app flexibility with model-driven app structure
AnswerD

Custom pages embed canvas-app controls and formulas directly inside the model-driven shell, so makers gain pixel-level layout freedom while retaining Dataverse tables, business rules and the unified interface. This satisfies the stem's requirement for a primary benefit: one component delivering both design flexibility and model-driven structure, without rebuilding either capability separately.

Why this answer

Custom pages in model-driven apps combine the drag-and-drop design flexibility of canvas apps with the data model, security, and navigation structure of model-driven apps. They allow makers to embed canvas-app-style UI inside a model-driven app while still accessing Dataverse tables and respecting the app's security model. This hybrid approach is the primary benefit and the reason custom pages exist.

Exam trap

AB-410 often tests the value proposition of custom pages, and the trap is selecting an option that overstates their scope (replacing all forms) or misattributes a security or performance benefit.

How to eliminate wrong answers

Option A is wrong because custom pages do not bypass security roles; they respect the model-driven app's security model and Dataverse role-based access, which is a core design principle. Option B is wrong because custom pages do not improve database performance — they are a UI composition feature and have no direct effect on Dataverse query performance. Option C is wrong because custom pages supplement rather than replace model-driven forms; they are used for scenarios where standard forms are insufficient, not to replace all forms.

28
MCQhard

You need to store sensitive information in your canvas app. How should you protect it?

A.Use a variable
B.Hide the control
C.Use Dataverse field-level security
D.Rename the field
AnswerC

Dataverse field-level security restricts individual column access by user or team, satisfying the requirement to protect sensitive information stored in the app's data layer. Unlike app-level controls, it enforces protection at the data source itself, so restricted values remain hidden even when queried directly through Microsoft Entra ID-authenticated connections.

Why this answer

Dataverse field-level security is the correct mechanism for protecting sensitive information because it restricts access to specific columns based on the user's security role, ensuring only authorized users can read or write those fields. This provides granular, server-side protection that cannot be bypassed by client-side tricks.

Exam trap

AB-410 often tests whether candidates rely on client-side obfuscation (hiding controls, renaming fields, using variables) instead of server-enforced column-level security like Dataverse field-level security.

How to eliminate wrong answers

Option A is wrong because a variable stores data in memory at runtime and provides no access control — anyone with the app can potentially read it. Option B is wrong because hiding a control is a UI-only measure that does not protect the underlying data, which can still be accessed via APIs or other views. Option D is wrong because renaming a field is cosmetic and does not enforce any security boundary.

29
MCQmedium

You are developing a canvas app that uses a custom connector to call an Azure Function. The function requires an API key. You need to store the API key securely so that it is not exposed in the app's source code or to users. What should you do?

A.Hardcode the API key directly in the custom connector's definition file and import it into the environment.
B.Configure the custom connector to use API key authentication and enter the key in the connector's security settings.
C.Store the API key in a SharePoint list and retrieve it at runtime using a LookUp function.
D.Store the API key in a variable using Set(varApiKey, "...") in the App.OnStart property.
AnswerB

Custom connectors support API key authentication, where the key is stored securely in the connector configuration and not in the app. The app references the connector without exposing the key. This is the recommended way to secure credentials for custom connectors.

Why this answer

The secure way to handle an API key for a custom connector is to configure API key authentication in the connector's security settings. The key is stored encrypted and not exposed in the app. Storing it in variables, SharePoint lists, or hardcoding it in the definition file all risk exposure and do not meet the security requirement.

Exam trap

The trap here is thinking that any storage location outside the app's code is secure, when only the connector's built-in authentication mechanism protects the key.

30
MCQmedium

You are building a canvas app that calls a custom connector to an internal REST API. The API requires an API key that must never be exposed to app users or stored in the app itself. You need the connector to authenticate without embedding the secret in the app. What should you configure?

A.Enable the connector's OAuth 2.0 implicit grant flow and pass the API key as a scope parameter.
B.Store the API key in a variable initialized in the App.OnStart property.
C.Configure the custom connector to use API key authentication, then create a connection that stores the key in the connection credentials.
D.Add the API key as a text input control on a hidden screen and reference it in the connector call.
AnswerC

Custom connectors support API key authentication, and the key is supplied when the connection is created, not in the app. Power Platform stores the credential securely with the connection, and the app references the connection by name. This keeps the secret out of the app definition and out of users' reach, satisfying the requirement to authenticate without embedding the key.

Why this answer

The requirement is to authenticate a custom connector without exposing the API key in the app. Custom connectors support API key authentication where the key is entered when creating the connection, and the platform stores it securely with the connection. The app then uses the connection, so the secret never appears in the app definition or to users.

Exam trap

The trap here is assuming the API key must be stored somewhere in the app code, when the connection credential store is the correct location.

31
MCQhard

You are troubleshooting a form in a model-driven app. The field is read-only even though the user has 'Write' permissions. What is the most likely cause?

A.The app icon
B.The browser cache
C.The user's password
D.Field security profile configuration
AnswerD

Field-level security profiles restrict individual columns independently of table-level Write privileges. If the field is included in a field security profile where the user lacks Update permission, it renders read-only on forms regardless of their broader Write access, which is the constraint described in the stem.

Why this answer

Field-level security in Dataverse is enforced through Field Security Profiles, which are separate from the standard security roles that grant table-level Read/Write/Create/Delete privileges. Even if a user has Write permission on the table via their security role, a Field Security Profile that grants only Read (or no access) on a specific column will override that and render the field read-only or hidden. This is the classic cause of a field appearing locked despite seemingly adequate permissions.

Exam trap

AB-410 often tests the misconception that table-level Write permission is sufficient to edit any column, when field security profiles silently override it.

How to eliminate wrong answers

Option A is wrong because the app icon is purely a cosmetic sitemap artifact and has no bearing on field editability. Option B is wrong because browser cache affects rendering/performance, not server-side authorization decisions — clearing cache would not restore write access. Option C is wrong because the user's password governs authentication, not the field-level authorization model; a valid session with correct credentials can still be blocked by field security.

32
MCQeasy

Which property of a Text Input control in a canvas app allows you to display a placeholder text?

A.Placeholder
B.HintText
C.Default
D.Value
AnswerB

HintText sets the greyed placeholder shown inside an empty Text Input control, disappearing once the user types. It satisfies the stem's requirement to display placeholder text, unlike Default, which pre-populates an actual value, or Format, which governs data type.

Why this answer

In Power Apps canvas apps, the Text Input control has a property called HintText that displays grey placeholder text when the control is empty. This property is specifically designed to show a hint or example of what the user should enter, and it disappears once the user starts typing. The other properties serve different purposes: Default sets the initial value, Value holds the current text, and Placeholder is not a valid property for Text Input controls.

Exam trap

AB-410 often tests the distinction between properties that set initial values (Default) and those that provide hints (HintText), so candidates might confuse 'Default' with placeholder functionality.

How to eliminate wrong answers

Option A is wrong because 'Placeholder' is not a property of the Text Input control in Power Apps; it is a common term in web development but not used here. Option C is wrong because 'Default' sets the initial value of the control, not a hint or placeholder text. Option D is wrong because 'Value' represents the current text entered by the user, not a placeholder.

33
MCQeasy

Which navigation element in a model-driven app allows you to group related tables together?

A.Forms
B.Groups
C.Charts
D.Views
AnswerB

Groups sit within the app's site map and contain related tables, letting administrators organise navigation into logical clusters. This directly satisfies the stem's requirement for grouping related tables, unlike areas, which partition the app at a higher level.

Why this answer

In Power Apps model-driven apps, the navigation structure is built from the site map, and 'Groups' are the navigation elements that organize related tables (entities) under a common heading in the app's navigation pane. Groups act as containers that cluster related tables so users can find them logically, such as grouping 'Sales' tables together. This is a core app-design concept in the Power Platform.

Exam trap

The trap is conflating data-presentation components (Forms, Views, Charts) with navigation-structure components — candidates who focus on 'tables' in the question may incorrectly pick Views or Forms, which are table-specific but not navigation grouping elements.

How to eliminate wrong answers

Option A is wrong because Forms define how individual records are displayed and edited for a single table — they are data-entry UI components, not navigation containers. Option C is wrong because Charts are visualizations of table data rendered on dashboards or views; they do not group tables in navigation. Option D is wrong because Views are saved queries that filter and display records of a single table, not navigation grouping elements.

34
MCQhard

A canvas app uses a Microsoft Copilot Studio agent to summarize long text fields. Users report that the first summary request after the app has been idle for several minutes takes much longer than subsequent requests, and occasionally times out. You must reduce the perceived latency without changing what the agent returns. What should you do?

A.Display a progress indicator and disable the summarize button while the agent call is in flight.
B.Send a lightweight warm-up request to the agent when the relevant screen becomes visible.
C.Move the agent call into an OnStart expression so it runs when the app loads rather than on first use.
D.Increase the app's data row limit so the agent has more context available on the first call.
AnswerB

A warm-up request primes the agent and its underlying model connection before the user submits real text, so the first meaningful call avoids cold-start latency. Triggering it on screen visibility means the warm-up runs while the user is reading or typing, hiding the delay. It does not alter the agent's output, which satisfies the constraint, and it reduces the chance of a timeout on the real request.

Why this answer

The delay is a cold-start effect on the agent, so priming it with a lightweight request when the screen appears lets initialization happen in the background while the user works. The real summarize call then runs against a warm agent, cutting perceived latency and reducing timeouts, without changing the agent's response content.

Exam trap

The trap here is treating a cold-start delay as a data-volume problem and reaching for the data row limit instead of warming the agent before the user's real request.

35
MCQhard

A canvas app calls a Microsoft Copilot Studio agent that returns a long generated summary. Users on tablets report the summary is cut off in a label, and scrolling within the label is not possible. You must show the full summary while keeping the layout stable. What should you do?

A.Set the label's Text property to a fixed number of characters and append an ellipsis.
B.Reduce the label's font size so the full summary fits within the fixed label height.
C.Set the label's AutoHeight property to true and place it inside a vertical container.
D.Place the label inside a vertical container with scrolling enabled and set the label to auto-height.
AnswerD

A vertical container with scrolling enabled lets the label grow to fit the full summary while the container keeps the overall layout fixed and provides a scrollbar to reach all the text. Combining auto-height on the label with a scrolling container satisfies both showing the full summary and keeping the layout stable on tablets.

Why this answer

To show a long summary without destabilizing the layout, put the auto-height label inside a vertical container that has scrolling enabled. The label expands to its full content height, and the container constrains the visible area while letting users scroll to read everything, which satisfies both requirements on tablets.

Exam trap

The trap here is using auto-height alone, which grows the label and shifts the layout, instead of pairing it with a scrolling container that bounds the visible area.

36
MCQmedium

You need to allow a user to select multiple items from a list in a canvas app. Which control should you use?

A.Radio button
B.Combo box
C.Toggle
D.Dropdown
AnswerB

A combo box supports multi-select through its SelectMultiple property, storing chosen items as a table the app can bind and iterate. Dropdowns and list boxes either restrict selection to one value or lack the searchable, tag-style selection behaviour required here.

Why this answer

A Combo box control in Power Apps canvas apps supports multi-select by default and allows users to pick several items from a list. It also supports search and is the standard control for multi-value selection scenarios. Radio buttons, toggles, and dropdowns are single-value controls.

Exam trap

AB-410 often tests the confusion between dropdown and combo box, since both look like list selectors — the trap is forgetting that only the combo box supports multi-select.

How to eliminate wrong answers

Option A is wrong because a radio button allows only one selection from a group. Option C is wrong because a toggle is a binary on/off control, not a list selector. Option D is wrong because a standard dropdown is single-select; only a combo box supports multi-select natively.

37
MCQhard

You are building a canvas app that uses a Microsoft Dataverse table with a column named 'Status' that has choices: New, In Progress, and Closed. You need to display the status as a colored badge in a gallery. Which approach should you use to dynamically set the badge color based on the status value?

A.Set the badge's Fill property to a formula that uses the ColorValue function to convert the status text directly to a color.
B.Create a separate table in Dataverse that maps status values to colors, and use a LookUp to retrieve the color.
C.Use conditional formatting in the gallery's template by setting the Color property of the badge to an If function with nested conditions.
D.Use a Switch function in the Fill property of a label or shape to map each status to a color.
AnswerD

The Switch function evaluates the status value and returns the corresponding color. This is the most straightforward and maintainable way to dynamically set colors based on a finite set of choices. It keeps the logic in one place and is easy to update if statuses change.

Why this answer

Using a Switch function in the Fill property is the most efficient way to map status values to colors. It provides a clear, maintainable mapping for a small set of choices and avoids extra data sources or complex nested conditions. This approach ensures the badge color updates dynamically based on the status value.

Exam trap

The trap here is overcomplicating the solution by introducing an external mapping table or misusing ColorValue, when a simple Switch function suffices for a static set of choices.

38
MCQmedium

You have created a Copilot agent for your canvas app. Where do you configure the topics the agent can respond to?

A.Dataverse environment settings
B.Copilot Studio
C.Canvas app formula bar
D.Power Apps App designer
AnswerB

Copilot Studio is where agent topics are authored and maintained, satisfying the stem's requirement to configure what the agent responds to. Topics define trigger phrases and conversation paths independently of the canvas app, which merely hosts the published agent. Editing topics in Power Apps Studio is not supported, so Copilot Studio remains the authoritative configuration surface.

Why this answer

Copilot agents created for Power Apps are built and managed in Copilot Studio (formerly Power Virtual Agents). Topics — the conversational intents and responses the agent can handle — are configured there, where you define trigger phrases, messages, questions, and actions. The canvas app simply surfaces the agent; the topic logic lives in Copilot Studio.

Exam trap

The trap is assuming the agent is configured inside the canvas app designer because that is where you add the Copilot control — but topic authoring always happens in Copilot Studio.

How to eliminate wrong answers

Option A is wrong because Dataverse environment settings control data storage, security roles, and environment-level configuration, not conversational topics for a Copilot agent. Option C is wrong because the canvas app formula bar is where Power Fx formulas are written for controls and behaviour in the app, not where agent topics are authored. Option D is wrong because the Power Apps App designer is used to lay out screens, controls, and data connections for the canvas app itself; while it can host the Copilot control, topic authoring is delegated to Copilot Studio.

39
Multi-Selecthard

Which TWO settings are crucial when deploying a model-driven app to production?

Select 2 answers
A.Environment variables
B.Hard-coded URLs
C.Manual editing of production forms
D.Local developer PC IP addresses
E.Managed solutions
AnswersA, E

Environment variables hold environment-specific values such as connection strings and URLs, letting one solution carry different configuration per target environment. They satisfy the production deployment constraint by separating configuration from the managed solution, avoiding hard-coded values that break across environments.

Why this answer

Environment variables (A) are crucial because they let you store environment-specific values such as connection strings, API endpoints, and SharePoint site URLs outside the app definition, so the same app can be promoted from dev to test to production without code changes. Managed solutions (E) are equally crucial because they are the supported deployment vehicle for production: they are locked against direct customization, support clean upgrade and patch paths, and allow clean uninstall, unlike unmanaged solutions. Hard-coded URLs (B) are wrong because they break when the app moves between environments and defeat the purpose of environment variables.

Manual editing of production forms (C) is wrong because production customizations must flow through solutions, not ad-hoc edits that create unmanaged layers and drift. Local developer PC IP addresses (D) are wrong because they are machine-specific and irrelevant to a cloud-hosted model-driven app's production configuration.

Exam trap

AB-410 often tests ALM fundamentals, and the trap is choosing 'manual editing' or 'hard-coded URLs' because they seem like direct control, when the exam expects recognition that managed solutions plus environment variables are the correct production pattern.

40
MCQeasy

You are building a canvas app and need to show the signed-in user a temporary success banner at the top of the screen after they submit a form. The banner should appear immediately and disappear on its own after a few seconds without navigating away. Which Power Apps feature should you use?

A.A Timer control that resets the form after the interval elapses.
B.A Navigate call to a dedicated success screen.
C.A Label control whose Visible property is set to true permanently.
D.A Notify function call with the NotificationType and a timeout.
AnswerD

Notify displays a transient banner at the top of the app and automatically dismisses it after the specified duration, which matches the requirement for a temporary success message that disappears without navigation. It is designed exactly for short-lived user feedback and requires no extra control or timer logic.

Why this answer

Notify is the built-in canvas app function for surfacing short-lived feedback at the top of the app. By specifying the notification type and a duration, the banner appears immediately and dismisses itself after the timeout, meeting the requirement without navigation or extra controls. Permanent labels, timer-driven resets, and screen navigation all introduce behavior the scenario explicitly excludes.

Exam trap

The trap here is overengineering with a Timer or a new screen when the platform provides a purpose-built transient notification function.

41
MCQmedium

You are building a model-driven app for a service desk. Managers need a view that shows only open cases assigned to their team, sorted by priority. The view must be available to all managers without giving them design privileges. What should you create?

A.A Power BI report embedded in the app that queries the Case table through the Dataverse connector.
B.A chart on the Case table grouped by priority and filtered to open cases, added to the app dashboard.
C.A system view on the Case table with a filter for open status and a sort on priority, included in the app's site map.
D.A personal view on the Case table saved by each manager in their own app session.
AnswerC

System views are created by customizers and are available to all users of the app based on their security roles. Filtering on open status and sorting by priority meets the display requirement, and placing the view in the app's site map makes it accessible to managers without granting them design privileges.

Why this answer

A system view is the correct artifact because it is defined once by a customizer and shared with all users who have access to the table and app. Filtering to open cases and sorting by priority satisfies the display requirement, and exposing it through the site map makes it reachable by managers without design privileges.

Exam trap

The trap here is confusing personal views, which are user-owned and unshared, with system views, which are shared through the app and controlled by security roles.

42
MCQeasy

In a canvas app, how do you change the order of items in a gallery?

A.Change the gallery theme
B.Use a filter
C.Drag and drop the items
D.Use the Sort function in the Items property
AnswerD

Applying Sort in the Items property reorders records by a named column, satisfying the requirement to change gallery item order. SortByColumns offers ascending or descending control, while Sort works on a single column. Because the gallery renders whatever the Items property returns, the reordered table displays immediately.

Why this answer

The order of items in a gallery is determined by the data returned from the Items property. To change the order, you apply a Sort, SortByColumns, or similar function in the Items property so the underlying collection or data source is presented in the desired sequence. This is the correct declarative way to control gallery ordering.

Exam trap

The trap is thinking that gallery item order can be changed by dragging items or applying a filter, when in fact ordering is controlled exclusively through the Items property using sort functions.

How to eliminate wrong answers

Option A is wrong because the gallery theme controls visual styling such as colors and fonts, not the order of items. Option B is wrong because a filter removes or includes records based on criteria; it does not reorder them. Option C is wrong because drag-and-drop is not a supported mechanism for reordering gallery items in Power Apps; the order is data-driven, not manually arranged.

43
MCQhard

You are building a model-driven app for a claims team. A business rule on the Claim table must hide a section of the form when the Claim Type is set to Auto, and must also set a default value for the Adjuster field. You need the rule to run in the browser and on mobile without custom code. Which approach should you use?

A.A Power Automate cloud flow triggered on the Claim row's creation that updates the Adjuster field and hides the section.
B.A JavaScript web resource registered on the form's OnLoad event that manipulates the section visibility and sets the Adjuster value.
C.A business rule on the Claim table with a condition on Claim Type that sets the Adjuster field and applies a Show or Hide action to the section.
D.A form-level column security profile that restricts the Adjuster field and hides the section when Claim Type is Auto.
AnswerC

Business rules are declarative components that run on the client form and on mobile without code. A condition on Claim Type can both set the Adjuster default and apply the Show or Hide action to the target section, so the Auto claim scenario behaves consistently across clients. They are the supported no-code mechanism for form-level field and section logic.

Why this answer

Business rules are the declarative way to implement conditional form behavior in model-driven apps. A condition on the Claim Type column can both assign a default to the Adjuster field and apply the Show or Hide action to a section, and the rule executes in the browser and in the mobile client without any custom code. JavaScript, cloud flows, and column security each address different concerns and cannot satisfy the combined visibility and defaulting requirement in a no-code manner.

Exam trap

The trap here is reaching for JavaScript because the requirement sounds complex, when a business rule already covers both the defaulting and the section visibility.

44
Multi-Selecthard

Which TWO actions should you take when troubleshooting a broken data connection in a canvas app?

Select 2 answers
A.Reinstall the browser
B.Delete the app
C.Rename the app
D.Verify the connection status in the Data pane
E.Check the user's security role
AnswersD, E

The Data pane lists every data source the canvas app references and shows whether each connection is currently connected or broken. Inspecting it satisfies the stem's troubleshooting requirement by isolating which connector has failed before investigating credentials or permissions.

Why this answer

Option D is correct because the Data pane in Power Apps canvas Studio lists every data source the app uses and shows its connection status, so a broken or unauthenticated connection is surfaced there and can be fixed by reconnecting or re-authenticating the source. Option E is correct because even a healthy connection will fail if the signed-in user lacks the required security role or table privileges in the underlying environment (for example, Dataverse or SharePoint), so verifying the user's security role isolates permission-based failures. Options A, B, and C are not troubleshooting steps for a data connection: reinstalling the browser does not affect Power Apps connector authentication, and deleting or renaming the app neither diagnoses nor repairs the connection and risks losing app work.

Exam trap

AB-410 often tests the temptation to pick destructive or irrelevant actions (delete, rename, reinstall) instead of the two diagnostic steps: check connection status and verify security roles.

45
Multi-Selectmedium

You are building a model-driven app for a customer support team. The app uses a custom table called Support Request. You need to configure the app so that users can quickly find requests by priority and see only requests assigned to their team. Which two actions should you perform? (Choose two.)

Select 2 answers
A.Add a dashboard that shows all Support Request records.
B.Create a view on the Support Request table that filters by the team and add it to the app.
C.Enable quick find on the Support Request table and configure it to search the Priority column.
D.Create a business rule that sets the Priority field to High when a request is created.
E.Add a chart on the Support Request table to display priority distribution.
AnswersB, C

Views define which records appear and can include filters such as team assignment. Adding the view to the model-driven app makes it available to users, satisfying the requirement to see only their team's requests. This is the standard way to control record visibility in a model-driven app.

Why this answer

To let users see only their team's requests, create a filtered view and add it to the app. To let them quickly find requests by priority, enable quick find and include the Priority column in its search configuration. Together these provide both the visibility scope and the search capability required.

Exam trap

The trap here is confusing visualization components like charts and dashboards with the mechanisms that actually filter records and enable search.

46
MCQhard

You are using Copilot to generate a canvas app. You want to add a specific layout. What is the most effective approach?

A.Describe the layout in the natural language prompt
B.Write C# code
C.Upload an image of the layout
D.Manually add every control first
AnswerA

Describing the layout in natural language directly satisfies Copilot's prompt-driven generation model, where the canvas app's structure is produced from textual intent rather than manual configuration. This is the most effective approach because Copilot interprets layout requirements from the prompt itself, avoiding extra manual steps.

Why this answer

When using Copilot to generate a canvas app, the most effective way to get a specific layout is to describe that layout clearly in the natural language prompt, because Copilot interprets descriptive text to generate screens, controls, and arrangements. Copilot for Power Apps is a natural-language-to-app generator, so prompt specificity directly drives output fidelity. Iterating on the prompt is the intended workflow.

Exam trap

AB-410 often tests whether candidates understand that Copilot for app generation is prompt-driven and text-based, so distractors like 'upload an image' or 'write code' exploit assumptions from other AI tools that accept multimodal input.

How to eliminate wrong answers

Option B is wrong because writing C# code is not how canvas apps are built — canvas apps use Power Fx, and Copilot does not accept C# as input for app generation. Option C is wrong because uploading an image of a layout is not a supported Copilot input for canvas app generation; Copilot works from text prompts. Option D is wrong because manually adding every control first defeats the purpose of using Copilot and is not the most effective approach — it is the slowest path and ignores the AI generation capability.

47
Multi-Selectmedium

You are building a canvas app that uses a Microsoft Copilot Studio agent to classify incoming support emails and route them. You need the classification to be reliable and the routing to be testable before release. Which two actions should you perform? (Choose two.)

Select 2 answers
A.Increase the agent's creativity setting so it can invent new categories when none fit.
B.Use the agent's raw text response directly as the routing key in an If expression.
C.Define the agent's output as a fixed set of category values and validate the returned value against that list in the app.
D.Hard-code the category list in the routing expression and skip validating the agent's response.
E.Test the app with representative emails, including ambiguous ones, and confirm the routing outcome for each.
AnswersC, E

Constraining the agent to a known set of categories and validating the response prevents free-text drift that would break routing logic. The app can compare the returned value against the allowed list and handle anything unexpected, such as by routing to a default queue. This makes classification deterministic enough to build reliable downstream rules.

Why this answer

Reliable classification requires constraining the agent to a known category set and validating responses before they drive routing, plus testing with representative and ambiguous emails to confirm outcomes. Together these make the behavior predictable and verifiable, while unconstrained or unvalidated output leaves routing brittle.

Exam trap

The trap here is trusting free-text agent output as a routing key and skipping validation, which works in demos but fails when wording varies between calls.

48
MCQhard

A user complains that their changes in a canvas app are not saved to the Dataverse table. What is the most common reason?

A.The data source is read-only
B.The SubmitForm function is not called
C.The connection is offline
D.The form is in View mode
AnswerB

Canvas apps only persist Dataverse records when a form control's OnSuccess submit action fires. Without invoking SubmitForm, edits remain in the local form control and no Patch or create request reaches Dataverse, so nothing is written to the table.

Why this answer

In Power Apps canvas apps, saving form data to Dataverse requires explicitly invoking SubmitForm(FormName) — typically from a button's OnSelect property. Editing fields on the form only updates the local form state; nothing is written to the data source until SubmitForm is called. If the developer forgot to wire SubmitForm to a control, the user's edits are discarded when the form is closed or reset.

Exam trap

The trap is that candidates look for infrastructure causes (offline, permissions) when the most common cause in canvas apps is a simple developer oversight — forgetting to call SubmitForm from a control.

How to eliminate wrong answers

Option A is wrong because a read-only data source would prevent editing entirely, not silently discard changes — and Dataverse tables are writable by default for users with appropriate security roles. Option C is wrong because an offline connection would surface a network error or use the app's offline capabilities, not silently fail to save. Option D is wrong because View mode would make fields non-editable, so the user could not enter changes in the first place — the symptom described (changes entered but not saved) points to a missing submit action.

49
MCQeasy

You are building a canvas app that includes a form for users to submit support requests. After a user submits the form, you want to display a temporary success message at the top of the screen that disappears after a few seconds. Which Power Apps function should you use to show this message?

A.Notify
B.Toast
C.Alert
D.Message
AnswerA

The Notify function displays a banner message at the top of the screen. It supports a notification type such as Success, and you can specify a duration in milliseconds. This exactly matches the requirement for a temporary success message that disappears automatically, making it the correct choice for user feedback after form submission.

Why this answer

The Notify function is designed to show temporary messages in canvas apps. It accepts a message string, a notification type like Success or Error, and an optional duration. This makes it ideal for confirming a successful form submission with a message that automatically disappears, providing clear user feedback without requiring additional controls.

Exam trap

The trap here is confusing functions from other Microsoft or web technologies, such as Alert or Toast, with the Power Apps native function Notify.

50
MCQeasy

You are creating a canvas app that must display a list of products from a SharePoint list. Users need to be able to select a product and see its details on a separate screen. Which control should you use to display the list and enable selection?

A.Data table control
B.Form control
C.Gallery control
D.Text input control
AnswerC

A Gallery control is designed to display a list of records and allows users to select an item. It supports templates for layout and can be bound to a data source like SharePoint. When a user selects an item, you can navigate to a detail screen and pass the selected record, fulfilling the requirement.

Why this answer

The Gallery control is specifically built to show a collection of records and handle selection. It can be customized with templates and connected to SharePoint. When an item is selected, the app can navigate to a detail screen, passing the selected item.

Other controls either handle single records or are not designed for list display and selection.

Exam trap

The trap here is confusing the Data table control with a Gallery; while both can show lists, the Gallery offers greater flexibility and is the intended control for custom list displays with selection.

51
MCQeasy

What is the first step to create a model-driven app from an existing table?

A.Select the table in the Power Apps maker portal
B.Write a Power Fx formula
C.Configure the command bar
D.Create a business rule
AnswerA

Model-driven apps are generated from Dataverse tables, so the maker first selects the existing table in the Power Apps maker portal, then creates the app around it. That selection is the prerequisite step before configuring forms, views and navigation.

Why this answer

To create a model-driven app from an existing table, the first step is to select that table in the Power Apps maker portal. Model-driven apps are metadata-driven and are built on top of Dataverse tables, so the table must be chosen as the starting data source before any forms, views, or navigation can be generated. The maker portal then auto-generates a basic app shell based on the selected table.

Exam trap

AB-410 often tests whether candidates confuse the starting point of model-driven apps (selecting a Dataverse table) with canvas app creation, which begins from a blank canvas or template.

How to eliminate wrong answers

Option B is wrong because Power Fx formulas are used for canvas apps and custom logic, not as the initial step for creating a model-driven app from a table. Option C is wrong because configuring the command bar is a customization step performed after the app and its pages exist, not the first step. Option D is wrong because business rules are logic components applied to tables/forms after the app structure is in place, not the entry point for app creation.

52
MCQhard

You have an app generated via natural language. You want to change the primary field of the app. Where do you change this?

A.In the table settings within Dataverse
B.In the App designer property pane
C.In the Canvas app properties
D.By deleting and recreating the app
AnswerA

The primary field (the column used as the record's display name) is defined on the table itself, so it is changed in Dataverse table settings. Editing it there updates the schema that the natural-language-generated app reads, propagating the change across its forms and views.

Why this answer

The primary field of a Dataverse table is defined at the table (entity) level in the table settings, not in the app. Changing it requires editing the table's primary column in Dataverse, which then propagates to any app (canvas or model-driven) that uses that table. This is why the change is made in table settings, not the app designer.

Exam trap

AB-410 often tests the misconception that app-level settings control table schema — candidates look in the App designer or canvas properties when the primary field is strictly a Dataverse table-level configuration.

How to eliminate wrong answers

Option B is wrong because the App designer property pane controls app-level properties like name, icon, and screen size — it cannot change a Dataverse table's primary field. Option C is wrong because canvas app properties govern the app's behavior and appearance, not the underlying table schema. Option D is wrong because deleting and recreating the app is destructive and unnecessary — the primary field is a table-level attribute that can be changed in place.

53
MCQhard

You notice that an image in your canvas app is blurry. What should you check to ensure it displays at high quality?

A.The app background color
B.The Image property and control dimensions
C.The number of data sources
D.The app theme
AnswerB

Blurriness arises when the image is stretched beyond its native resolution or the control's dimensions distort its aspect ratio. Setting the correct Image property and matching control dimensions preserves native pixel density, satisfying the stem's requirement for high-quality display.

Why this answer

Image quality in a canvas app depends on the source image resolution and how the Image property and control dimensions are configured. If the control is stretched beyond the image's native resolution, or if the Image property points to a low-resolution asset, the result is blurriness. Checking these settings ensures the image is displayed at its intended size and quality.

Exam trap

The trap is assuming that app-level settings like theme or background affect image quality, when the actual cause is almost always the Image property source or the control's dimensions relative to the image resolution.

How to eliminate wrong answers

Option A is wrong because the app background color has no effect on image rendering quality. Option C is wrong because the number of data sources affects performance and data binding, not image sharpness. Option D is wrong because the app theme controls colors, fonts, and styling, not image resolution or scaling.

54
MCQeasy

In a model-driven app, which view should you modify if you want to change the columns displayed to users by default?

A.System view
B.Form
C.Dashboard
D.Personal view
AnswerA

System views define the default column set and filtering that all users see unless a personal view overrides them. Modifying the relevant system view changes the columns displayed by default across the model-driven app, satisfying the requirement directly.

Why this answer

In a model-driven app, the default columns users see in a grid are controlled by the view selected for that entity. System views are the out-of-the-box views (e.g., Active Accounts) that define which columns appear by default; modifying the system view changes what all users see unless overridden by personal views. This is the correct place to change default displayed columns.

Exam trap

AB-410 often tests the confusion between views, forms, and dashboards — candidates pick Form thinking it controls displayed columns, when forms control record layout and views control grid columns.

How to eliminate wrong answers

Option B is wrong because a Form controls the layout of a single record's fields for create/read/update, not the columns shown in a list or grid. Option C is wrong because a Dashboard aggregates charts and lists but does not define the default column set for an entity's grid. Option D is wrong because a Personal view is user-specific and only affects the individual who created it — it does not change the default columns for all users.

55
MCQhard

You are building a canvas app that connects to a Microsoft Dataverse table with over 100,000 records. Users report that the gallery shows only the first few hundred records and filtering does not return expected results. You need to ensure the app retrieves and filters all records correctly. What should you do?

A.Increase the app's data row limit to 2000 in Settings.
B.Change the data source to a SharePoint list, which supports larger datasets.
C.Load all records into a collection on app start using ClearCollect.
D.Use delegable functions and operators in the gallery's Items property, such as Filter and Sort on supported columns.
AnswerD

Delegation pushes filtering and sorting to Dataverse, so all records are processed server-side and only the needed results are returned. Using delegable functions like Filter and Sort with supported operators ensures correct results regardless of table size. This is the proper solution for large datasets.

Why this answer

The symptom of seeing only a few hundred records indicates non-delegable queries hitting the data row limit. The correct fix is to use delegable functions and operators so Dataverse processes the query server-side. This ensures filtering and sorting apply to the entire table and returns accurate results for large datasets.

Exam trap

The trap here is treating the data row limit as the fix, when the real issue is that the query is not delegable to the data source.

56
MCQmedium

You are building a canvas app in Power Apps that connects to a Microsoft Dataverse table containing 200,000 contact records. Users report that the gallery takes more than 30 seconds to load. You need to reduce the load time while keeping the gallery functional for searching by last name. What should you do?

A.Convert the canvas app to a model-driven app to leverage server-side rendering.
B.Set the gallery's Items property to 'FirstN(Contacts, 100)' to limit the number of records shown.
C.Increase the app's screen size and add more galleries to distribute the records.
D.Enable the 'Explicit column selection' feature and set the gallery's Items property to a Filter expression that uses a delegable query with the Last Name column.
AnswerD

Explicit column selection limits the columns retrieved to only those displayed, reducing payload size. Combined with a delegable Filter on Last Name, Dataverse processes the filtering server-side, so only matching records are returned. This dramatically reduces load time for large tables while preserving the search capability the users need.

Why this answer

Explicit column selection reduces the data transferred by fetching only needed columns, and delegable filtering on Last Name ensures Dataverse handles the query server-side. Together, they minimize load time while enabling efficient search. Other options either do not address the data volume issue or introduce new problems without solving the performance bottleneck.

Exam trap

The trap here is assuming that limiting records with FirstN or increasing screen size improves performance, when the real issue is inefficient data retrieval and lack of delegation.

57
Multi-Selectmedium

Which THREE types of controls are commonly used to input data in a canvas app?

Select 3 answers
A.Text input
B.Dropdown
C.Label
D.Icon
E.Toggle
AnswersA, B, E

A Text input control captures free-form alphanumeric entry from the user and binds that value to a variable, collection or data source field. It satisfies the data-input requirement directly, unlike display controls such as Label or Gallery that only present existing data.

Why this answer

Text input (A) is a classic data-entry control in Power Apps canvas apps, allowing users to type free-form values that can be bound to a data source via its Default and OnChange properties. Dropdown (B) is also a standard input control, letting users select a single value from a predefined list, commonly populated from a data source or Items property. Toggle (E) is an input control that captures a Boolean true/false value, typically used for yes/no or on/off fields.

Label (C) is a display-only control used to show text or data, not to input it, and Icon (D) is a purely decorative or action-triggering graphic, so neither is used for data input.

Exam trap

AB-410 often tests the distinction between display controls and input controls, so candidates who see a Label or Icon and assume it collects data will pick the wrong options.

58
MCQhard

You are creating a canvas app that must let users edit a Dataverse record in a form and save changes back to the table. You want the form to validate required fields before saving and to submit only when validation passes. Which control and property combination should you use?

A.An Edit form control with its OnSuccess property running SubmitForm.
B.An Edit form control with its OnSelect property running SubmitForm(Form).
C.An Edit form control with a Button whose OnSelect runs If(Form.Valid, SubmitForm(Form)).
D.A Button whose OnSelect runs Patch(Project, Defaults(Project), Form.Updates).
AnswerC

The Edit form tracks required-field validation and exposes it through the Valid property. Gating SubmitForm behind If(Form.Valid, ...) ensures the record is written only when all required fields pass validation, which is exactly the behavior the scenario specifies for editing and saving a Dataverse record.

Why this answer

An Edit form exposes a Valid property that reflects whether all required fields have acceptable values. Placing If(Form.Valid, SubmitForm(Form)) in a button's OnSelect ensures the save only happens when validation passes, giving the controlled edit-and-save behavior required. Triggering submission from post-success handlers, bypassing the form with Patch, or relying on a nonexistent form property all fail to provide the validation gate.

Exam trap

The trap here is assuming the form submits itself or that a post-success handler can serve as the trigger, when submission must be explicitly gated on the Valid property.

59
MCQeasy

You are creating a canvas app that displays a list of products. You want the app to show a warning icon next to any product whose stock quantity is below 10. The gallery already has an Image control. What should you set the Visible property of the Image control to?

A.First(Products).Stock < 10
B.CountRows(Products) < 10
C.Stock < 10
D.ThisItem.Stock < 10
AnswerD

In a gallery, ThisItem refers to the current row. Setting the Image control's Visible property to ThisItem.Stock < 10 makes the icon appear only when the stock is below 10. This is the correct per-row conditional visibility expression for a gallery item.

Why this answer

Inside a gallery, each control is bound to a row, and ThisItem exposes that row's fields. Using ThisItem.Stock < 10 in the Visible property evaluates per row, so the warning icon appears only for products with stock below 10. Other approaches either evaluate globally or reference the wrong scope.

Exam trap

The trap here is forgetting the ThisItem scope and trying to reference the column name directly or using an aggregate function instead of the current row.

60
MCQhard

A canvas app uses a SQL Server table with over 100,000 rows. Users report that a gallery showing filtered records is slow and sometimes returns incomplete results. You have already set the data source to enable delegation where possible. Which action should you take next to improve performance and correctness?

A.Move the table into a collection on App.OnStart and filter the collection instead.
B.Replace the Filter function with a Search function on the gallery's Items property.
C.Add an index on the columns used in the filter and rewrite the query to use only delegable operators and functions.
D.Increase the app's data row limit to 2000 in the advanced settings.
AnswerC

Delegation sends filtering to the data source, but it only works when the column is indexed and the expression uses delegable operators. Adding an index on the filtered columns lets SQL Server evaluate the predicate efficiently, and restricting the expression to delegable functions ensures the full result set is returned correctly. This addresses both the slowness and the incomplete results.

Why this answer

When a canvas app must work with large SQL Server tables, delegation is essential, and delegation depends on both the data source and the expression. Ensuring the filtered columns are indexed and that the filter uses only delegable operators and functions lets the server return the complete, correct result set efficiently instead of falling back to a partial local scan.

Exam trap

The trap here is thinking that raising the data row limit solves delegation problems, when it only increases how much data is pulled locally.

61
MCQhard

You are creating a model-driven app for a property management company. The app must include a custom page that displays a map of all properties using a third-party JavaScript mapping library, and this page must appear in the main site map alongside standard table views. Which approach should you use to add this custom page?

A.Build a separate Power Apps portal and link to it from the model-driven app's navigation using a URL.
B.Add a web resource of type HTML to a table form and configure the form as the app's default page.
C.Create a canvas app and embed it as a custom page in the model-driven app, then add the page to the app's navigation.
D.Create a Power BI report with a map visual and embed it in the model-driven app using a dashboard.
AnswerC

Model-driven apps support custom pages, which are canvas apps embedded directly into the model-driven app's navigation. This allows you to use canvas controls and custom JavaScript web resources or PCF controls to render a map, and the page appears in the site map like any other component. It is the supported way to mix custom UI with model-driven navigation.

Why this answer

Custom pages allow you to embed a canvas app inside a model-driven app, giving you the flexibility of canvas controls while keeping the model-driven navigation and security model. You can add the custom page to the app's site map, making it accessible alongside table views. This is the recommended approach for custom UI such as a map.

Exam trap

The trap here is thinking that any web resource or embedded report can serve as a full navigation page, when only custom pages provide that integration in a model-driven app.

62
MCQmedium

What is the primary function of a 'Business Process Flow' in a model-driven app?

A.To store data
B.To design the UI layout
C.To guide users through a process
D.To perform math calculations
AnswerC

A business process flow defines the stages and steps a user must follow, rendering them as a guided bar within the model-driven app. It enforces a consistent sequence of actions, satisfying the requirement to steer users through a defined process rather than leaving it to discretion.

Why this answer

A Business Process Flow (BPF) in a model-driven app provides a guided, stage-based visual path that walks users through a defined sequence of steps to complete a business process consistently. It enforces process order, captures required data at each stage, and can branch based on conditions. Its primary function is user guidance through a process, not data storage or UI layout.

Exam trap

AB-410 often tests the confusion between BPFs and workflows or Power Automate flows, so candidates who think 'process' means background automation pick a data or calculation answer instead of the user-guidance answer.

How to eliminate wrong answers

Option A is wrong because data storage is the role of tables/entities, not BPFs — a BPF references existing table columns but does not itself store records. Option B is wrong because UI layout is defined by forms, views, and the app designer, whereas a BPF renders as a stage bar at the top of a form. Option D is wrong because math calculations are performed by calculated columns, rollup columns, or Power Fx formulas, not by BPFs.

63
MCQmedium

You are building a canvas app for a field inspection team. Inspectors must attach a photo and then have the app suggest a defect category from the image before they submit. You want to use the built-in AI capability in Power Apps rather than training a custom model. Which control or component should you add to the app to accomplish this?

A.The Text recognizer component from the AI Builder controls
B.The Image classification component from the AI Builder controls
C.The Business card reader component from the AI Builder controls
D.The Object detection component from the AI Builder controls
AnswerB

The Image classification component in AI Builder is purpose-built to assign a single category label to an image based on a model trained on labeled examples. In Power Apps you can bind it to the camera or attachment image and read its predicted label to populate the defect category. This directly matches the requirement to suggest a category from a photo without writing custom code.

Why this answer

Image classification is the AI Builder capability that assigns a single category label to an entire image. Because the inspectors need the app to suggest a defect category from a photo, binding an image classification component to the captured image yields the predicted label that can populate the category field. The other AI Builder components extract text, detect objects, or read business cards, none of which produce a defect category.

Exam trap

The trap here is confusing object detection, which returns bounding boxes for multiple items, with image classification, which returns one overall category label for the whole image.

64
MCQeasy

Which component in a model-driven app is used to present a summary of data?

A.Command bar
B.Table
C.Dashboard
D.Business process flow
AnswerC

A dashboard presents aggregated charts and views summarising data from multiple tables on a single canvas, directly satisfying the requirement to present a summary. Unlike forms, which display individual records, or views, which list rows from one table, dashboards consolidate metrics for at-a-glance insight.

Why this answer

A dashboard in a model-driven app is specifically designed to present a consolidated summary of data using tiles, charts, and lists pulled from multiple tables and views. It aggregates key metrics and visualizations onto a single surface so users can monitor business performance at a glance. Tables store the underlying records, while dashboards surface summarized views of that data.

Exam trap

AB-410 often tests the distinction between data storage components (tables) and data presentation components (dashboards, charts, views), so candidates who see 'summary of data' and reflexively pick 'Table' because tables hold data fall into the trap.

How to eliminate wrong answers

Option A is wrong because the command bar provides action buttons (New, Delete, Run Report, etc.) for executing operations, not for summarizing data. Option B is wrong because a table is the data storage structure (entity) that holds rows and columns of records, not a summary presentation layer. Option D is wrong because a business process flow is a guided stage-based workflow that walks users through a defined sequence of steps, not a data summary visualization.

65
MCQeasy

Which menu in the Power Apps maker portal do you use to view all your tables?

A.Flows
B.Solutions
C.Apps
D.Data
AnswerD

The Data menu in the Power Apps maker portal exposes Tables, alongside other data components such as connections and flows. Selecting it lists every table available in the selected environment, directly satisfying the requirement to view all tables from one location.

Why this answer

The Data menu in the Power Apps maker portal is where you can view and manage tables, including Dataverse tables and other data sources. It provides a centralized view of the data entities available to your apps and environments. This is the correct location for viewing all tables.

Exam trap

AB-410 often tests portal navigation, and candidates confuse the Data menu with Solutions or Apps because those areas also list related components, but only Data is dedicated to tables.

How to eliminate wrong answers

Option A is wrong because Flows refers to Power Automate flows, not tables. Option B is wrong because Solutions is used to package and transport apps, flows, and other components, not to browse tables directly. Option C is wrong because Apps lists canvas apps and model-driven apps, not the underlying tables.

66
Multi-Selecthard

You are configuring a Power Apps canvas app that uses a Dataverse table with a lookup column. You need to ensure the app remains performant and returns accurate results as the table grows beyond the delegation limit. Which two actions should you take? (Choose two.)

Select 2 answers
A.Ensure filters and lookups reference columns that are indexed in Dataverse.
B.Set the app's Data row limit to 2000 in Settings so more rows are processed locally.
C.Wrap the table in a ClearCollect on OnStart and query the collection thereafter.
D.Increase the delegation limit by editing the app's JSON source directly.
E.Use the LookUp function with a delegable predicate on an indexed column instead of First(Filter(...)).
AnswersA, E

Delegation depends on the connector being able to translate the query, and Dataverse can efficiently serve predicates on indexed columns. Filtering or looking up on an indexed column keeps the operation delegable and fast, so results stay accurate even when the table contains far more rows than the client would otherwise process.

Why this answer

Performance and accuracy under delegation come from keeping queries delegable and reducing transferred rows. Using LookUp with a delegable predicate returns just the matching record, and ensuring predicates target indexed Dataverse columns lets the connector push work to the server. Raising local row limits or copying data into a collection does not remove the underlying cap and can produce incomplete, misleading results as the table scales.

Exam trap

The trap here is believing the local data row limit can be raised or bypassed to fix delegation, when the real fix is writing delegable queries against indexed columns.

67
MCQmedium

When you generate a canvas app from natural language, what happens to the data?

A.It creates a new Dataverse table
B.It deletes existing data
C.It exports data to Excel
D.It connects to a random SQL server
AnswerA

The generator creates a schema in Dataverse based on the prompt.

Why this answer

When you use Copilot to generate a canvas app from a natural-language description, Power Apps automatically provisions a new Dataverse table to store the app's data, complete with columns inferred from the prompt. This gives the generated app a working, persistent data layer without the maker having to design the schema manually. The generated table is created in the currently selected environment.

Exam trap

The trap is assuming Copilot connects to an existing external data source; in reality, generated canvas apps default to a brand-new Dataverse table created in the current environment.

How to eliminate wrong answers

Option B is wrong because app generation is a create operation — it never deletes existing data; Copilot has no destructive behavior against existing tables. Option C is wrong because exporting to Excel is a separate data operation and is not part of the app-generation flow; the generated app stores data in Dataverse, not in a spreadsheet. Option D is wrong because Copilot does not connect to an arbitrary or 'random' SQL server — it uses Dataverse, Microsoft's native low-code data platform, as the default data store for generated apps.

68
MCQeasy

You are building a canvas app and need to display a running total of items in a shopping cart as users add products. The total must update immediately whenever an item is added or removed. Which approach should you use?

A.Store the cart items in a collection and update the label's Text property inside the OnSelect of each Add to Cart button.
B.Use a variable that is incremented in each Add to Cart button's OnSelect and decremented in each Remove button's OnSelect.
C.Store the cart items in a collection and set a label's Text property to Sum(CartItems, Price * Quantity).
D.Write the cart items to a Dataverse table and use a timer control to refresh the total every few seconds.
AnswerC

A collection holds the cart in memory, and the label's Text property recalculates automatically whenever the collection changes. Sum over the Price times Quantity expression produces the running total, and because the label depends on the collection, adding or removing an item updates the display immediately without extra code.

Why this answer

Binding the label to Sum over the cart collection makes the total a derived value that recalculates automatically whenever the collection changes. This declarative approach avoids drift and handles every mutation path, including removal and quantity edits, without duplicating logic in individual button handlers.

Exam trap

The trap here is assuming the total must be maintained imperatively, when Power Fx recalculates any expression that references a changed collection automatically.

69
MCQmedium

You are building a canvas app that uses a Microsoft Dataverse table named 'Projects'. You need to ensure that when a user opens the app, only projects where the 'Owner' column equals the current user's email are loaded. Which function should you use in the app's OnStart property to filter the data efficiently?

A.ClearCollect(MyProjects, Projects)
B.Search(Projects, User().Email, "Owner")
C.LookUp(Projects, Owner = User().Email)
D.Filter(Projects, Owner = User().Email)
AnswerD

The Filter function with a delegation-friendly condition on Dataverse will retrieve only the matching records from the server. User().Email returns the current user's email, which can be compared to the Owner column. This is efficient and ensures only relevant data is loaded.

Why this answer

The Filter function is the correct choice because it retrieves a table of records matching the condition and delegates the filtering to Dataverse, ensuring efficiency. Using User().Email dynamically filters by the current user, so only their projects are loaded. This approach is both secure and performant.

Exam trap

The trap here is using LookUp for multiple records or ClearCollect to load all data, when Filter is specifically designed to return a filtered table and delegate the query.

70
MCQeasy

You are building a canvas app that displays a list of products from a Dataverse table. You want to show the total price of all products in a label. Which function should you use in the label's Text property?

A.Average(Products, Price)
B.Max(Products, Price)
C.Sum(Products, Price)
D.CountRows(Products)
AnswerC

Sum aggregates numeric values across a table. Using Sum(Products, Price) calculates the total of the Price column for all records. This is the correct function for displaying a total in a label, provided the data is already loaded or the function can delegate to Dataverse.

Why this answer

To display the total price of all products, the label must aggregate the Price column across all records. The Sum function performs this addition. Other aggregate functions like Average, CountRows, and Max return different metrics and would not produce the total price.

Exam trap

The trap here is confusing aggregate functions, particularly selecting Average or Max when a total sum is explicitly requested.

71
MCQeasy

A developer is building a canvas app that must let a user pick a single date from a calendar-style picker. The selected date then filters a gallery of records. Which control should the developer add to the screen for this purpose?

A.Dropdown
B.Slider
C.Date picker
D.Text input
AnswerC

The Date picker control provides a calendar interface for selecting one date, and its SelectedDate property can be referenced in the gallery's Items filter. This directly satisfies the requirement of picking a single date that drives a filter, without extra configuration for multi-date or time selection.

Why this answer

The Date picker control is purpose-built to let a user choose one date from a calendar, and its SelectedDate property integrates directly with a gallery's Items filter. It provides the calendar-style selection the scenario describes without custom parsing or workarounds.

Exam trap

The trap here is reaching for a text input or dropdown to capture a date when a dedicated Date picker control already exposes a SelectedDate property for filtering.

72
MCQhard

You are building a canvas app that uses a gallery to display orders from a Dataverse table. Users need to filter the gallery by order status and sort by order date. The app must perform well with over 10,000 orders. Which approach should you use?

A.Use Collect(FilteredOrders, Filter(Orders, Status = varStatus)) in OnVisible, then sort the collection in the gallery.
B.Use Filter(Orders, Status = varStatus) and set the gallery's Sort property to OrderDate descending.
C.Use SortByColumns(Filter(Orders, Status = varStatus), "OrderDate", Descending) in the gallery's Items property.
D.Use Filter(Orders, Status = varStatus) and Sort(Filter(Orders, Status = varStatus), OrderDate, Descending) in the gallery's Items property.
AnswerC

SortByColumns is specifically designed for delegation with Dataverse. Combining it with a delegable Filter on Status ensures both filtering and sorting occur server-side. This returns all matching rows in the correct order and performs well with large datasets, meeting the requirements.

Why this answer

To filter and sort a large Dataverse table efficiently, both operations must delegate to the server. SortByColumns is delegable for Dataverse and can be combined with a delegable Filter. Using Sort or collecting into a collection risks hitting row limits and returning incomplete or incorrectly sorted data.

Exam trap

The trap here is assuming that any Sort function delegates, when in fact SortByColumns is required for reliable delegation with Dataverse.

73
MCQhard

You are building a canvas app that reads and writes data in a Dataverse table. You need to ensure that users can only see records they own or that are shared with them, and that this security is enforced regardless of how the app queries the data. What should you configure?

A.Apply a Filter function in every gallery and form to restrict records to the current user.
B.Configure Dataverse security roles and record ownership so access is enforced by the platform.
C.Enable the table's auditing setting so access attempts are logged and reviewed.
D.Set the app's data source to use a service account with limited permissions.
AnswerB

Dataverse enforces row-level security through security roles, ownership, and sharing, and this applies to every client including canvas apps. When a user queries the table, the platform returns only records they are permitted to see. This guarantees consistent enforcement regardless of how the app is built, satisfying the requirement.

Why this answer

Dataverse enforces record-level security through security roles, ownership, and sharing, and these rules apply to every client that accesses the data, including canvas apps. Configuring roles and ownership ensures users see only the records they own or that are shared with them, and the enforcement cannot be bypassed by app-level queries.

Exam trap

The trap here is believing that filtering records in app formulas provides security, when Dataverse security roles and ownership are what actually enforce access.

74
MCQhard

You are using the 'Copilot' control in your canvas app. How do you link it to your specific data?

A.Change the app name
B.Configure the Data sources property
C.Write a custom API connector
D.Update the environment variable
AnswerB

The Copilot control reads its knowledge from the Data sources property. Adding your table or connector there grounds responses in your specific data, which is the supported mechanism for linking Copilot to a particular dataset within the canvas app.

Why this answer

The Copilot control in a canvas app is connected to your data through its Data sources property, where you select the tables or entities the Copilot should use to answer questions and generate responses. Configuring this property is what grounds the Copilot in your specific business data rather than generic knowledge.

Exam trap

AB-410 often tests whether candidates overcomplicate Copilot data binding by choosing custom connectors or environment variables, when the correct answer is the built-in Data sources property on the control itself.

How to eliminate wrong answers

Option A is wrong because changing the app name has no effect on the Copilot's data access or behavior. Option C is wrong because writing a custom API connector is unnecessary — the Copilot control has a built-in Data sources property for linking to Dataverse or other supported sources. Option D is wrong because environment variables are used for configuration values like URLs or keys, not for defining which data the Copilot can query.

75
MCQhard

You are building a canvas app that uses a Microsoft Dataverse table with delegation. A gallery must show only rows where the Status column equals 'Active' and the CreatedOn is within the last 30 days. The table contains over 100,000 rows. Which approach ensures the gallery returns the correct set of rows without loading the entire table into memory?

A.Set the gallery's Items to Filter(Accounts, Status = "Active") and apply the date condition in the gallery's OnVisible property using a collection.
B.Set the gallery's Items to FirstN(Accounts, 100000) and then apply Filter on the result to reduce the set.
C.Use the Search function in the gallery's Items to match the status and date, since Search always delegates to Dataverse.
D.Set the gallery's Items to Filter(Accounts, Status = "Active" && CreatedOn >= DateAdd(Now(), -30, Days)) and rely on Dataverse delegation for both conditions.
AnswerD

Dataverse supports delegation for Filter with equality and comparison operators on columns like Status and CreatedOn, so both conditions are translated into a server-side query. This returns only the matching rows and avoids downloading the full table, satisfying the 100,000-row requirement efficiently.

Why this answer

Dataverse delegates Filter conditions using equality and comparison operators, so combining Status and CreatedOn in a single Filter expression pushes both predicates to the server. This returns only the active rows created in the last 30 days, avoiding the overhead and row-limit issues of client-side filtering.

Exam trap

The trap here is splitting the filter so one condition runs client-side in a collection, which silently breaks delegation and truncates results on large tables.

Page 1 of 2 · 83 questions totalNext →

Ready to test yourself?

Try a timed practice session using only Building The Apps questions.