Lately, the Power Platform community has been buzzing with excitement over Generative Pages. Touted as a game-changer, they’re often presented as the long-awaited solution for building custom interfaces within Model-Driven Apps. And while the enthusiasm is understandable, I can’t help but feel that the hype is—at least partially—misplaced.
Let me explain.
🦄 The Myth: “Finally, Custom UI in Model-Driven Apps!”
A recurring narrative I’ve seen is that Generative Pages are being celebrated as the first real way to build custom UIs in Model-Driven Apps. But for those of us who’ve been around since the Dynamics CRM days, this isn’t exactly new territory.
We’ve always had the ability to create custom interfaces using HTML WebResources. Whether it was jQuery in the early days or more modern stacks like React + TypeScript + Fluent UI, the platform has long supported advanced UI customization. The only difference? Back then, you had to roll up your sleeves and build it yourself.
🔍 The Reality: Generative Pages Are a New Abstraction, Not a New Capability
Generative Pages are a fantastic addition—don’t get me wrong. They lower the barrier to entry, especially for makers and newcomers who might not be familiar with the extensibility model of Dataverse. But they’re not a replacement for pro-code solutions. They’re a new abstraction layer, not a new frontier.
If you’re looking for true flexibility, performance, and control, custom WebResources still reign supreme. And if you’re wondering how to get started with those, I’ve written extensively on the topic:
- Dataverse Web Resources with React, Typescript and FluentUI (_neronotte's way)
- Form-based Dataverse Web Resources with React, Typescript and FluentUI - Part 1
- Form-based Dataverse Web Resources with React, Typescript and FluentUI - Part 2
- Say Goodbye to CRA, Hello to Vite - the last but most important, because the previous articles rely on an NPM template that no longer exists.
These posts walk through everything from scaffolding your project to handling context injection and deploying with PACX. They’re not just tutorials—they’re a testament to the maturity and power of the platform’s extensibility model.
And they were written before the Generative AI era. Now you can also leverage GitHub Copilot capabilities in VS or VS Code to implement the logic, making the gap with Generative Pages even lower.
🧪 WebResources vs PCFs: The Debugging and Testing Advantage
Another point that often gets overlooked in the Generative Pages vs. WebResources vs. PCF debate is the developer experience—especially when it comes to debugging and testing.
Compared to PCFs (PowerApps Component Framework), WebResources are significantly easier to debug. You can run them in the browser, inspect them with standard dev tools, and iterate quickly without the need for complex build pipelines or deployment steps. This makes them ideal for rapid prototyping and iterative development.
PCFs, while powerful, come with a steeper learning curve and a more rigid development lifecycle. Debugging often requires attaching to the browser process, dealing with iframes, and managing a more complex deployment model. For many use cases, especially those that don’t require deep integration with the control lifecycle, WebResources are simply more efficient.
💾 Source Control and DevOps: Still a Win for WebResources
One of the lesser-known advantages of WebResources is how well they integrate with source control and CI/CD pipelines. Thanks to tools like Power Platform CLI and PACX, you can manage your WebResource projects in Git, automate deployments, and maintain a clean, versioned history of your codebase.
This is still a significant advantage over Generative Pages, which—at least for now—lack the same level of DevOps maturity. While Microsoft is making strides in this area, the ability to fully own and manage your codebase remains a key differentiator for WebResources.
🌟 The Real Value Behind Generative Pages
Generative Pages are worth the excitement because they fundamentally shift the accessibility of custom experiences in Model-Driven Apps.
For years, building tailored interfaces meant diving into pro-code solutions like WebResources or PCF—powerful, but often out of reach for makers and business users.
Generative Pages change that equation by introducing an abstraction layer that democratizes UI creation without sacrificing Dataverse integration or solution governance.
They accelerate time-to-value, reduce dependency on specialized front-end skills, and align perfectly with the low-code ethos of Power Platform.
In short, they don’t replace pro-code—they complement it, enabling organizations to deliver functional, data-centric pages faster and with less friction, while still leaving room for deeper customization when needed.
🤔 Final Thoughts
Let’s welcome Generative Pages for what they are: a helpful tool in the toolbox. But let’s also continue to educate and advocate for the powerful capabilities that have been there all along. The Power Platform isn’t just evolving—it’s maturing. And as professionals, it’s our job to guide that evolution with clarity and context.
If you’re serious about building rich, enterprise-grade experiences in Model-Driven Apps, don’t overlook the power of WebResources. They’re not just legacy—they’re battle-tested, flexible, and still incredibly relevant.
Top comments (0)