AB-410 Building Intelligent Applications Exam Topics and Questions

This topic sets the ground beneath everything else on the exam. Before any agent runs or any flow fires, someone has to make the right calls about solution architecture, environment strategy, and data structure. The exam tests whether you can make those calls, not just describe them. Gaps here ripple through every other topic, so treat this as the area where a shaky understanding of ALM or table configuration will quietly drain your score.

– Solution design and architecture decisions

The exam expects you to move from a business requirement to a concrete set of Power Platform components. That means reading a scenario and identifying which built-in agents belong in the solution, which extensibility options are appropriate, and which environment type fits the situation. Environment types are a favourite area for tricky items: development, sandbox, and production are not interchangeable, and the exam rewards knowing the rules around managed versus unmanaged solutions and where ALM strategy constrains your choices. Recommending extensibility options demands that you distinguish between what the platform provides out of the box and what genuinely requires a custom connector, a plug-in, or a code component. The ALM strategy questions tie solution layering to deployment pipelines, so be clear on how publisher prefixes, solution segments, and environment variables interact when you move a solution from dev to production.

– Data modelling and table configuration

A large slice of this topic lives in the data workspace. You need to be comfortable creating and modifying both standard and custom tables, and the exam goes deep on the properties that govern how those tables behave: ownership type, attachments, auditing, and duplicate detection settings all appear as configuration decisions, not background knowledge. Column types matter more than their names suggest. Calculated, rollup, and formula columns each have distinct evaluation timing and scope, and confusing them is a common source of lost marks. Table relationships control form and view behaviour downstream, so understanding cascade rules and relationship types is worth the time. The exam also covers prompt columns and row summaries, which are newer Dataverse features tied to Copilot integration. Treat them as first-class configuration tasks rather than optional extras, because the exam does.

– Security and user experience configuration

Security in this topic means Dataverse security: table-level permissions, column security profiles, and how security roles interact with the sharing model. The exam distinguishes between what a security role permits and what a sharing record grants, and items often present a scenario where the candidate must choose the least-privilege option that still meets the business need. Public views and main forms are also examinable here, which might seem like a canvas concern but belongs in the foundation because these artefacts are configured at the table level before any app consumes them. Configuring a main form incorrectly blocks downstream model-driven app behaviour, so the exam uses foundation-level configuration errors as the source of application-level symptoms. Knowing the direction of that dependency is what separates a confident answer from a guess.

How Create a foundation for intelligent applications is tested

Items in this topic almost always present a scenario: a business has a stated requirement and a current environment setup, and you must choose the design decision that fits both. The trap is that multiple options will look plausible if you are thinking about the technology in isolation. The exam rewards matching the option to the constraint in the scenario, whether that constraint is ALM stage, environment type, or licensing boundary.

Data modelling items tend to arrive as configuration decisions rather than conceptual questions. You will not be asked to define a rollup column; you will be asked which column type is appropriate given a specific aggregation requirement, and the wrong options will each be plausible for a different reason.

Security items reward precision. Candidates who treat security roles and column security profiles as interchangeable lose marks consistently. The exam also tests whether you know which configuration belongs at the table level versus the app level, because placing it in the wrong layer is a realistic mistake that produces a wrong answer without looking wrong at first read.

Where the first topic was about setting up the platform correctly, this one is about building what users actually touch. Model-driven apps and canvas apps each have their own configuration model, their own access controls, and their own failure modes in the exam. The split between them is not cosmetic: the exam treats them as genuinely different tools, and items will penalise you for applying canvas-app thinking to a model-driven scenario and vice versa.

– Model-driven apps: composition and access

Building a model-driven app on the exam means understanding the relationship between its parts: forms, views, charts, dashboards, and the sitemap that surfaces them. Configuring a form is not just a drag-and-drop exercise; the exam tests tab layout, section behaviour, and how form components respond to the security role of the logged-in user. Views carry their own access configuration, separate from the form, and items regularly present a scenario where a user can see a record in a view but cannot open the form, or the reverse. You need to know why that happens and how to fix it. Charts and dashboards are configured inside the app rather than at the table level, and the exam distinguishes between personal and system dashboards when access is the issue. Generative pages created with natural language are also part of this sub-topic set, and the exam expects you to know where they fit in the composition of a model-driven app.

– Canvas apps: build, performance, and reliability

Canvas apps test a wider range of skills than model-driven apps do. Starting from data is the common path, but the exam also probes design decisions: accessibility requirements, responsive layout choices, and performance patterns. The Monitor tool is explicitly examinable for canvas apps, and items will ask you to interpret what Monitor surfaces and what action to take as a result. Error handling is another area where candidates lose marks by treating it as optional. The exam rewards knowing where to place IfError and how to surface errors to users without crashing the app. Variables and collections have distinct scoping rules, and the exam uses those rules to create plausible wrong answers. Named formulas, user-defined functions, and component libraries are grouped under reusability, and the exam distinguishes between them: a named formula is not a user-defined function, and the difference is testable.

– Automation and Copilot integration from apps

Automating business processes from a canvas app means calling Power Automate flows, and the exam tests the connection between the app and the flow: how data is passed, how results come back, and what happens when the flow fails. This is where error handling from the previous group connects to automation. Creating a Copilot Studio agent from a canvas app is a newer capability that the exam treats as a distinct task with its own configuration steps, not a side effect of building the app. The exam rewards knowing when to use a Copilot Studio agent versus embedding AI directly in the app, because the scenarios are designed to make both options look reasonable. Access configuration for model-driven apps is also part of this topic, covering which security roles are assigned at the app level versus inherited from the environment, and why the distinction matters for deployment.

How Create intelligent applications is tested

This topic generates some of the highest item volume because it covers two distinct app types and their supporting features. Expect scenario-based items where the requirement points clearly to one app type but the wrong options describe valid features of the other.

Model-driven app items reward knowing the sequence of decisions: table first, then form and view configuration, then app composition, then access. Items that describe a symptom (a user cannot see a button, a view returns no records) reward tracing the symptom back to the correct configuration layer.

Canvas app items are more likely to test specific formula behaviour. The exam does not ask you to write a formula from scratch, but it does present scenarios where the right answer depends on knowing how a particular function behaves with a particular data type. Monitor-based items reward interpreting a diagnostic output rather than recalling a fact.

Candidates most often drop marks by treating form access and app access as the same setting, and by underestimating the specificity of the reusability sub-topics. Named formulas, user-defined functions, and component libraries are each tested on their own terms.

The previous two topics built the data layer and the user-facing apps. This topic is about making those apps do work automatically and intelligently. Cloud flows, AI prompts, and business process logic are the three pillars here, and the exam treats each one as a separate discipline with its own configuration model. The overlap between them is also testable: knowing when a business rule is the right tool versus a cloud flow versus a formula column is one of the most reliable ways to lose marks if you have not thought it through.

– Cloud flows: triggers, connectors, and actions

Cloud flow items on this exam start with the trigger. Recommending the right trigger for a given scenario is a standalone skill: instant, automated, and scheduled triggers each have constraints, and the exam uses those constraints to make wrong options plausible. Connector selection is similar: the exam does not ask you to list connectors but does ask which connector type is appropriate when a standard connector exists, when a custom connector is needed, and when a connection reference is the correct abstraction for an ALM-aware solution. Configuring actions means knowing how to pass data between steps, how to reference dynamic content, and how to use expressions where static values are insufficient. Approvals via cloud flows are a dedicated sub-topic, and the exam tests the approval action's configuration options rather than the concept of approvals in general. Managing approvals includes parallel branching, timeout handling, and reassignment, all of which appear as scenario-based choices.

– Flow control and troubleshooting

Conditions and loops are the mechanics of flow control, and the exam tests them at the level of configuration decisions rather than abstract logic. The most common trap is the scope action: candidates who have not used it in practice tend to misplace it or confuse it with a condition. Loop configuration includes the apply-to-each and do-until patterns, and the exam distinguishes between them based on the scenario's data shape. Testing and troubleshooting cloud flows is explicitly listed, and the exam rewards knowing what the run history surfaces, how to re-run a failed flow from a specific action, and how to use the flow checker before publishing. Troubleshooting items present a symptom (a flow does not trigger, an action returns an error) and reward identifying the configuration cause rather than a generic debugging step. This is an area where practical experience with failed flows pays off directly.

– AI Hub: prompts and models

AI Hub is the part of this topic most likely to catch candidates who focused their preparation on the traditional Power Platform features. Building prompts from templates or from blank, adding knowledge sources, customising model settings, and adding inputs are all distinct configuration steps, and the exam tests them individually. Consuming a prompt in an app and consuming a prompt in a cloud flow are also separate sub-topics, because the integration point differs: in an app you use a connector action, in a flow you use the AI Builder prompt action. The exam rewards knowing which integration path applies to which runtime context. Consuming an AI model (as opposed to a prompt) follows a similar pattern but applies to prebuilt and custom AI Builder models. Candidates who conflate prompts with models in AI Hub tend to select the wrong consumption method, which is a consistent source of dropped marks.

– Business rules, process flows, and column logic

Business rules, business process flows, calculated columns, rollup columns, and formula columns each operate at a different layer of the platform and have different evaluation timing, scope, and limitations. The exam exploits this by presenting a requirement that multiple tools could satisfy and asking which one is most appropriate. Business rules run on the form or the server depending on scope, and that distinction changes the answer when the requirement mentions mobile clients or API access. Business process flows guide users through stages; they are not automation tools in the same sense as cloud flows, and the exam rewards keeping that boundary clear. Calculated and rollup columns are evaluated server-side on a schedule or on demand, while formula columns use Power Fx and evaluate differently. Evaluating use cases for business logic means being able to map a requirement to the correct tool, which is the skill the exam is ultimately testing across this entire sub-topic group.

How Build business application logic and automation is tested

This topic rewards breadth over depth. The exam does not ask you to build a complex flow from memory; it asks you to identify which component solves a described requirement, and it makes sure the wrong options are all real Power Platform features.

Cloud flow items are heavily scenario-driven. The scenario will specify a trigger condition, a data source, and a business outcome, and the strongest option matches all three constraints rather than just one or two. Candidates who anchor on the trigger and ignore the connector constraint, or vice versa, consistently select a plausible but wrong option.

AI Hub items reward knowing the difference between a prompt and a model, and between consuming either in an app versus a flow. The exam does not test AI concepts in the abstract; it tests configuration steps and integration paths.

Business logic items reward the ability to evaluate trade-offs. Knowing that a business rule cannot run server-side with certain scope settings, or that a rollup column does not recalculate in real time, is the kind of constraint the exam uses to eliminate wrong options. Candidates who treat these tools as interchangeable drop marks here reliably.