Building Power Apps with AI & Copilot

When you use Copilot to create a canvas app, what is generated first, before the app itself?

• AOne or more Dataverse tables, populated with representative sample data✓
• BA finished three-screen canvas app, complete with placeholder controls
• CA published model-driven app designer configuration
• DA Power Automate cloud flow that triggers on new records

Answer: Copilot's canvas app creation works in two connected phases: it first generates one or more Dataverse tables with appropriate columns and representative sample data, then builds the app on top of that model. The finished app with its screens is the second phase, not the first. A cloud flow and a model-driven app designer configuration are unrelated outputs of this canvas app flow.

In Power Apps, which entry point starts the Copilot conversation that creates both a data model and a canvas app?

• ASelecting Start with data, then Create new data✓
• BOpening the Power Apps Component Framework CLI
• CSelecting Add page, then Dashboard
• DOpening the model-driven app designer's Settings pane

Answer: The conversation-driven creation flow begins on the Power Apps home screen by selecting Start with data and then Create new data, which opens the Copilot panel. The PCF CLI is a professional-developer tool for building custom controls, not for starting a Copilot conversation. Add page then Dashboard and the model-driven app designer's Settings pane are steps used later, for building dashboards and enabling Copilot for users respectively.

After Copilot generates a canvas app from a description, what three screens does the resulting app typically include?

• ABrowse, detail, and edit screens✓
• BLogin, forms, and views screens
• CHome, navigation, and settings screens
• DDashboard, timeline, and KPI screens

Answer: Copilot builds a complete create, read, update, and delete experience as a three-screen canvas app: a browse screen, a detail screen, and an edit screen. Dashboard, timeline, and KPI elements belong to model-driven apps rather than this generated canvas app structure. Home/navigation/settings and login/forms/views are not the screen set the units describe for a Copilot-generated canvas app.

While reviewing a Copilot-generated data model, a maker types 'Change the Priority column to a Choice type with options: Low, Normal, High, Critical.' What does this demonstrate?

• AWriting a Power Fx formula to validate the Priority column
• BConfiguring a business process flow stage for priority escalation
• CRefining the generated data model through continued natural language conversation with Copilot✓
• DPublishing the app with an AI-generated description

Answer: This is an example of refining the Dataverse data model Copilot generated, by continuing the natural language conversation to adjust column types and options. It is not a Power Fx formula, which is written for app logic rather than data-model refinement in this workspace. Configuring a business process flow stage and publishing with an AI-generated description are separate steps that happen later, after the data model and app exist.

How does creating a model-driven app with Copilot differ from creating a canvas app with Copilot?

• AThe canvas flow requires Visual Studio Code and the Power Platform CLI for every step, while the model-driven flow does not need either of those developer tools
• BThe model-driven flow builds an app designed for data management on Dataverse, while the canvas flow builds a task-focused browse/detail/edit app✓
• CThe model-driven flow cannot use sample data, while the canvas flow always includes it
• DThe model-driven flow skips generating a data model entirely and only generates the user interface, forms, navigation, and dashboards directly from a description

Answer: Both flows follow a similar pattern of generating a Dataverse data model through conversation, but the model-driven flow then builds an app suited to data management scenarios, while the canvas flow produces a task-focused browse, detail, and edit app. The model-driven flow does generate a Dataverse data model first, just like the canvas flow. Neither flow requires Visual Studio Code, and both populate sample data as part of the generated tables.

What default views does Copilot typically add to a table in a generated model-driven app?

• ADraft, Published, and Archived
• BOpen, Escalated, and Closed
• CBrowse, Detail, and Edit
• DActive records, Inactive records, and My records✓

Answer: A Copilot-generated model-driven app table comes with system-generated views named Active records, Inactive records, and My records. Open, Escalated, and Closed describe a support-case status field rather than the default view names. Browse, Detail, and Edit are canvas app screen names, and Draft, Published, and Archived aren't views the units describe for a generated table.

In the model-driven app designer's Add page options, what does a Generative page do?

• ADisplays a pre-built dashboard of charts and KPI cards
• BEmbeds a static web resource such as a custom HTML page
• CSurfaces an existing Dataverse table, using its default form and view
• DLets a maker describe a specialised page, using natural language, and an agent builds it✓

Answer: A Generative page lets a maker describe the specialised page they want in natural language, and an agent builds it accordingly. Surfacing a Dataverse table with its default form and view describes the standard Dataverse table page type instead. Embedding a static HTML resource describes the Web resource page type, and a pre-built set of charts and KPI cards describes the Dashboard page type.

When publishing a Copilot-generated model-driven app, what optional AI feature is available in the Publish dialog?

• AAn AI-generated Power Fx validation rule for every column
• BAn AI-generated business process flow for the app's main table
• CAn AI-generated agent flow that runs on publish
• DAn AI-generated description of the app based on its components✓

Answer: The Publish dialog offers an option to have Copilot write an AI-generated description of the app based on its components, which can also be triggered later from the app's Settings pane. Generating a business process flow or a Power Fx validation rule automatically at publish time is not a feature the units describe. An AI-generated agent flow belongs to a different part of Power Platform, not this Publish dialog option.

Once a model-driven app built with Copilot is published, what can Microsoft 365 Copilot do for its users?

• AGenerate a new canvas app from the same Dataverse tables
• BAnswer natural language questions grounded in the app's Dataverse data, respecting each user's security role✓
• CReplace the app's business process flow, substituting a conversational Copilot Studio agent for every stage instead
• DAutomatically republish the app whenever the underlying data model changes, without any review by the maker who built it

Answer: Once enabled, Microsoft 365 Copilot lets app users ask natural language questions and receive answers grounded in the app's Dataverse data, while still respecting each user's security role. Automatically republishing the app on data model changes is not a behaviour the units attribute to this feature. Generating a new canvas app and replacing the business process flow with an agent are unrelated actions this in-app Copilot experience does not perform.

Across both canvas and model-driven app creation, what two connected phases does Copilot's conversation-driven building process follow?

• AIt first generates the app's user interface, then connects it to a data source
• BIt first publishes a draft app, then asks the maker to add a data model
• CIt first configures security roles, then builds the business process flow
• DIt first builds the Dataverse data model, then generates the app on top of that model✓

Answer: Copilot needs to understand the data before it can build an app to manage it, so it first creates the Dataverse data model and then generates the app on top of that model, for both canvas and model-driven apps. Building the interface before connecting a data source reverses this order. Configuring security roles first and publishing a draft before adding a data model are not the sequence either creation flow follows.