6.3 Creating Generative Pages with Natural Language

What Generative Pages Are

Generative pages are an AI-driven app-building experience inside model-driven apps: you describe the page you want in natural language, point the agent at the Microsoft Dataverse tables it should use, and it generates a working page — real React code written in TypeScript that covers both the front-end user experience and the business logic that talks to your data. You then refine the result conversationally, adjusting elements, layout, and functionality in real time. Generative pages are supported only in model-driven apps — not in canvas apps — and the feature exists to compress hours of hand-built UI work into a prompt-and-iterate session.

Creating a Generative Page

At make.powerapps.com, open a model-driven app in the app designer and select Add page → Generative page, then choose Describe a page. (The same dialog also lists existing generative pages you can reuse; it is filtered to Published pages by default.) The full-page generative experience opens, and from there:

1. Write the prompt — functional requirements plus an optional UX specification, up to 50,000 characters. Example: 'Build a page showing Account records as a gallery of cards with a modern look and feel; include name, image, website, email, and phone; make the gallery scrollable.' The Intelligent Apps Catalog provides a Prompt Catalog of pre-built templates for common patterns such as galleries, Kanban boards, and dashboards.
2. Add data — link up to six Dataverse tables; the page performs CRUD (create, read, update, delete) operations against them.
3. Attach images (optional) — a napkin sketch or wireframe to steer the layout. To display a specific image on the finished page, store it in a referenced table, host it publicly, or add it as a web resource and give the agent the URL.
4. Optionally enable Include images — lets the agent draw from a curated library of about 25,000 stock images (these are not AI-generated) for placeholders, backgrounds, and empty states.
5. Choose a model and select Generate page — GPT-4.1 is currently the only model available in the maker studio; newer frontier models are reachable through the AI code generation tools approach.

Generation runs as an observable multistep build: thought streaming (the agent's interpretation, assumptions, and execution plan), code generation, transpilation, and final rendering — if the result does not appear automatically, open the Preview tab. The browser-based maker experience requires an environment located in the United States, Great Britain, Australia, or Singapore; the code-first approach, using AI code generation tools such as Claude Code with direct access to the TypeScript and React output, is available worldwide on public clouds. The maker experience requires no additional AI credits.

Iterating and Publishing

Refinement is conversational: send follow-up prompts to fix errors, adjust layout, or add functionality, and attach a screenshot of the current preview to steer visuals. You can also open the Code tab to inspect the generated TypeScript/React and edit it manually — edits are saved as a new iteration — and use Compare to view a diff between iterations (available from the second iteration of the session). An Accessibility assistant scans the code after each iteration and can hand violations to the agent with Auto fix.

A page reaches users only after Save and Publish, which publishes the app's pending changes; a page created from the app designer lands in the app's sitemap, so it appears in navigation automatically. Generative pages are solution-aware — they travel as UX Agent Project rows when you export the app's solution — but only the first prompt and the last published code move between environments; the full conversation history stays behind. Pages created during the preview phase need a one-time migration, triggered simply by opening them in the designer. For richer flows, pages can accept the input parameters recordId, entityName, and data, and custom code can open them with Xrm.Navigation.navigateTo.

Security and Governance

Generative pages read and write through Dataverse as the signed-in user, so they respect table permissions and security roles — a user without read rights on a table sees none of its data on the page. The generated code is a best-effort attempt with accessibility and security practices in mind, but it is not guaranteed production-ready: the maker remains responsible for validating it against organizational standards and compliance requirements before publishing.

Generative Pages vs Custom Pages vs Standard Table Pages

• Standard table pages (views plus forms): the default for record grids and CRUD forms — pure configuration, no code.
• Generative pages: bespoke, rich UX such as galleries, Kanban boards, and dashboards, produced in minutes from a prompt; grounded on Dataverse only.
• Custom pages: canvas-designer pages with pixel-level control, Power Fx formulas, and connectors beyond Dataverse — maximum control, maximum manual effort.

Current Limitations (Exam Fodder)

• Dataverse only — up to six tables per page, CRUD operations only; no other data sources can be used.
• Prompts are capped at 50,000 characters, and the maker studio accepts prompts in US English only.
• The maker-studio experience is limited to US, Great Britain, Australia, and Singapore environments.
• No collaboration — ensure only one maker works on a generative page at a time.
• Only a fixed set of column types is supported: Text, Multiline Text, Whole Number, Decimal Number, Floating Point Number, Currency, Choice, Yes/No, Date and Time, Date Only, Lookup, Customer, Image, Status, Status Reason, and Unique Identifier.
• Pages must be published before users see them, and you must validate the generated code yourself before rollout.