Hello everyone and welcome to my blog. You have probably started hearing the term generative pages floating around in the model-driven apps world, and if you are wondering what they actually are and whether they are worth your time, this post is for you. In today’s blog, let’s cover the basics – what a generative page is, what purpose it serves, and how you can create one yourself in just a few minutes.
I am keeping this one deliberately beginner friendly, because it is meant to be the starting point before you dive into the more advanced scenarios like passing data in and out of these pages from client script.
So what exactly is a generative page?
A generative page is a new type of page you can add to a model-driven app, where instead of hand building the layout control by control, you simply describe what you want in plain English and the maker platform generates a working, data-bound page for you. Think of it as telling an AI assistant “build me a page that shows my high value accounts as cards with a call button”, and getting back a real, functioning page wired to your Dataverse data.
Under the hood it generates modern, code-first components (React based), but the beauty is you do not have to write that code by hand to get started. You describe, it generates, you refine by chatting with it further, and then you save and publish – just like any other page in your app.

How is it different from a regular custom page?
Good question, because we already have custom pages built with canvas style controls. The difference is in how you build them:
- A custom page is built the canvas way – you drag controls onto a screen, bind them, and write Power Fx. You are in full manual control of every element.
- A generative page is built by description – you tell it the outcome you want and it assembles the page and the code for you. You then refine it conversationally rather than pixel by pixel.
Neither is “better” – they are different tools for different moments. Generative pages shine when you want to go from idea to a working, good looking, data aware page fast, without wiring everything up by hand.
What purpose does it serve? When would you use one?
Here are the kinds of scenarios where I find generative pages genuinely useful:
- Rich custom experiences that would be tedious to build by hand – a nicely laid out gallery of records as cards, a mini dashboard, a guided selection screen.
- Selector and picker dialogs – open a generative page as a dialog, let the user pick something, and hand the result back to your form.
- Side pane companions – surface a contextual, purpose built view right next to the record the user is working on.
- Rapid prototyping – when you want to show a stakeholder a working page in minutes rather than spend an afternoon in the canvas designer.
The common thread is: you want something more tailored than a standard form or view, but you do not want to build and maintain a lot of custom plumbing to get there.
Before you start – a quick prerequisite
There is one thing that trips people up, so let me call it out up front. At the time of writing, generative pages are only available if your environment is in one of these regions – United States, Great Britain, Australia, or Singapore. If you do not see the generative page option at all, your environment region is almost always the reason. The good news is that the feature itself does not need any extra AI credits or special licensing to try out.
You will also need a model-driven app to add the page to, and at least one Dataverse table with some data to show.
Creating your first generative page, step by step
Here is the full flow from start to finish. I have placed each screenshot right next to the step it belongs to, so you can follow along.
- Sign in to the maker portal at make.powerapps.com and select the environment you want to work in from the top right environment picker.
- Open a model-driven app for editing (or create a new one) so that you land in the app designer.
- Select Add page, then choose Generative page, and pick Describe a page.

- In the prompt box, describe the page you want in plain language. Be specific about the table, the fields to show, how it should look, and any buttons or actions. For example, let it make a bit interesting:
“Build a page that lets the user find and select a single Account. Show records from the Account table as a scrollable gallery of cards, each showing the account name, email, phone number, and city. Put a “Select” button on each card. When the user clicks Select, calldataApi.setPageOutputwith an object{ action: "selected", accountId, accountName }using the chosen record’s id and name, then close the dialog by callingXrm.Navigation.navigateBack(). Also set up the page to accept an accountrecordIdinput parameter.”

- Select Add data and add the Dataverse table(s) your page needs. You can add more than one table if your page spans related data.

- Select Generate page. You will see it think through the request, generate the components, and then render a live preview of your page.
- Not quite right? Just keep chatting with it – “make the cards larger”, “add a search box at the top”, “sort by created date”. Each message refines the page. There is also a Code view if you want to inspect what was generated, and remember you are ultimately responsible for validating that generated code.

- When you are happy, select Save, then Save and Publish to publish the page along with your app.

That is genuinely it. In the time it takes to describe what you want, you have a working, published page in your app.
A few things to keep in mind
- Output varies. Because the page is generated, the exact result can differ from run to run. Treat the first generation as a starting point and refine it with follow up prompts.
- Be specific in your prompt. The more clearly you describe the fields, layout, and actions, the closer the first result lands to what you had in mind.
- It is still evolving. Generative pages are a newer capability, so keep an eye on the official docs for the latest on regions, limits, and features.
Where to go next
Once you have a generative page built, the real fun begins when you start opening it from your forms, passing context into it, and returning a selected value back. I have covered that full round trip – navigating to and from a generative page using the client API – in a dedicated post, so do check that out as your next step.
Final thoughts
Generative pages lower the barrier to building rich, tailored experiences in model-driven apps in a big way. You describe the outcome, the platform does the heavy lifting, and you refine by conversation. If you have been putting off building that custom screen because the canvas work felt like too much effort, this is a great time to give generative pages a try. Build one on a table you know well and see how close it gets on the first go – I think you will be pleasantly surprised.
For the official overview, the current region availability, and how to set up input parameters, refer to Microsoft’s documentation:
Hope this helped. You will also like the below posts.
Debajit Dutta
Discover more from Debajit's Power Apps & Dynamics 365 Blog
Subscribe to get the latest posts sent to your email.