AI-first React & Blazor framework + Fluent UI components for Dataverse — the code-first Power Pages alternative

From zero to portal hero in under 60 minutes!

Build smarter, faster, and cleaner with Power Portals Pro—a framework of tools and components for Microsoft Dataverse, built for AI-first development. Describe the portal you want to your AI coding agent: our MCP server gives it every component's real API and your own Dataverse schema, so it works from the real API and your real schema instead of guessing. Launch a fully working custom portal in record time, without sacrificing flexibility, scalability or performance.

  • MCP server for AI agents
  • React or Blazor + Fluent UI
  • Metadata-driven validation
  • Forms + sub-grids
  • ASP.NET Core Identity auth
  • No Power Pages required
React Blazor Fluent UI
Power Portals Pro portal screenshot showing a Dataverse-backed form and sub-grid
Power Portals Pro screenshot

AI-first development

Describe the portal. Your AI agent builds it.

Software is increasingly written by AI coding agents, and Power Portals Pro is built for them. Its MCP server, and the instructions every project ships with, give Claude, GitHub Copilot, Cursor and any other agent that speaks the Model Context Protocol first-hand knowledge of the framework and of your own Dataverse environment — so the agent works from the real API and your real schema rather than guessing at them.

You ask

Add a page where signed-in customers see their open support cases in a grid, grouped by status, and can open one to update it. Each customer should only ever see their own cases.

Your agent

  1. Finds the table in your environment — its columns, its status choices and your saved views with their real ids — with describe_table, list_choices and list_views.
  2. Looks up the exact parameters of MainGrid and RecordContext with get_component_api, and starts from a working sample for your stack with get_example.
  3. Follows the project's secure-a-table skill, so each customer's cases are filtered on the server, where no page can get round it.
  4. Adds the list and edit pages with the project's add-table-pages skill, in React or Blazor, as ordinary code in your repository.

It knows the framework

Every component's real parameters, types and defaults on both stacks, complete working samples, the guides and the conventions — looked up rather than half-remembered. No license key, nothing to sign up for.

It reads your Dataverse

The table and column names you actually have, your option-set values, relationship names and saved views with their real GUIDs — the things that exist only in your environment and in no documentation anywhere. It never creates, changes or deletes your business data: what it changes is the portal's own setup, and only once you have approved it.

Setup and deployment, by asking

The agent checks what a new portal is missing and sets it up: the managed solution, the Entra app registrations, the Dataverse application user and its security roles, the email sender — and then Azure App Service and Key Vault to deploy it. It shows you each change before it makes it.

Projects that brief the agent

Every project the templates create ships an AGENTS.md with the framework's conventions, a .mcp.json that pins the MCP server to the project's version, and skills that walk the agent through setting up the portal, securing a table and adding its pages.

Upgrades with a plan

Ask your agent to upgrade the portal and the MCP server hands it every breaking change between your version and the new one, each with its migration steps — and the project's upgrade-portal skill works through them.

Works with the agent you use

Claude Code, GitHub Copilot in Visual Studio and VS Code, Cursor, and any other client that speaks the Model Context Protocol. The server runs on your machine through dnx, which comes with the .NET 10 SDK.

Build custom Dataverse portals fast—with metadata-driven forms and grids.

Power Portals Pro gives you production-ready React and Blazor components that read and save form data back to Microsoft Dataverse. Controls configure themselves using Dataverse metadata (labels, tooltips, required/constraints), and the framework makes localization and translation straightforward.

From This:

{/* Metadata-driven fields (label/required/min/max/length from Dataverse) */}
<RecordContext>
  <Section>
    <SectionColumn headerText="Account Info">
      <ColumnEdit columnName="name" />
      <ColumnEdit columnName="telephone1" />
      <ColumnEdit columnName="websiteurl" />
      <ColumnEdit columnName="parentaccountid" />
      <ColumnEdit columnName="tickersymbol" />
    </SectionColumn>
    <SectionColumn headerText="Primary Contact">
      <LookupRecordContext columnName="primarycontactid">
        <Section>
          <ColumnEdit columnName="firstname" />
          <ColumnEdit columnName="lastname" />
          <ColumnEdit columnName="emailaddress1" />
          <ColumnEdit columnName="mobilephone" />
          <ColumnEdit columnName="jobtitle" />
        </Section>
      </LookupRecordContext>
    </SectionColumn>
  </Section>
  <SubGrid relationshipName="contact_customer_accounts" />
</RecordContext>

To This:

Power Portals Pro portal screenshot showing a Dataverse-backed form and sub-grid

See it in action

Real screens from the live demo — record pages, grids and card layouts, Kanban boards, calendars, maps, multi-table search, dashboards and charts, embedded Power BI reports, timelines, rich text, inline file previews, and built-in image viewing and editing. Click any screenshot to try it.

Dataverse-aware by default

Power Portals Pro components automatically configure themselves using Dataverse metadata—so you spend less time wiring labels, tooltips, required rules, and constraints, and more time shipping portal experiences.

React & Blazor + Fluent UI

Build on a modern React + Vite + TypeScript SPA or ASP.NET Core Blazor — both rendered with Microsoft's Fluent UI design system and both exposing the same metadata-driven components and Dataverse capabilities. Pick whichever stack matches your team's skills; the developer experience, theming, accessibility, and component coverage stay consistent across both.

Metadata-driven UI

Labels, tooltips, required flags, min/max ranges, and length limits come from Dataverse—so every editor on every page stays consistent with your data model without per-form configuration. Rename a column or tighten a constraint in Dataverse and every portal page that references it picks up the change on the next load, with no portal-side code edits or redeploy required.

Atomic saves + full framework flexibility

When users save, all changes—form fields plus grid and sub-grid edits—persist in a single Dataverse transaction, so updates are atomic: everything succeeds or everything rolls back. And because you're building a true custom portal on React + Vite or ASP.NET Core Blazor, the full npm and .NET ecosystems are yours: libraries, middleware, auth providers, logging, and background services.

Build internal portals, not just customer portals

Power Portals Pro isn't only for customer-facing sites—internal employee portals, departmental tools, and back-office apps are first-class use cases. Because staff sign in as their own Dataverse systemuser, your existing role assignments are the security model: no duplicate Contact records, no parallel permission system, and a single codebase can serve internal staff and external customers side by side.

Localization & translation ready

Localize every table label, tooltip, view name, and choice option into any language—you're never limited to the languages Dataverse ships a language pack for. Source translations from installed language packs, supply your own JSON files for any culture, or combine the two with JSON entries overriding anything Dataverse provides—and switch a user's language at runtime without a redeploy.

Machine translation in minutes

Translate your entire site into dozens of languages in minutes. From the built-in admin page, upload a localization file and pick your target languages, and every string is machine-translated through Azure Translator, DeepL, or Google—reusing anything already translated so you only pay for what's new. Download the results per language or as a single zip and drop them in to ship a fully localized portal, no translator in the loop.

Authentication & authorization included

Built on ASP.NET Core Identity with first-class support for two audiences at once. Staff sign in as their own Dataverse systemuser via Microsoft / Entra ID, and Dataverse security roles enforce row-, column-, and business-unit-level access through CallerId impersonation. Customer-facing users map to Dataverse contacts and sign in with a local account or passkey, Microsoft, Google, or an OpenID Connect or SAML 2.0 identity provider — Okta, Auth0, Microsoft Entra External ID, a customer's own Entra tenant, AD FS — each added in configuration, with no code.

Dataverse-native security (preview)

Let Dataverse enforce portal security itself — built on Power Pages' unified Dataverse security. Configure web roles and table permissions the standard Power Pages way, and the framework automatically provisions system-managed Dataverse users for your portal contacts so security roles govern every read and write, with zero permission-handler code. Because the security configuration lives entirely in Power Pages, a portal can move to or from an actual Power Pages site without friction. In preview alongside Microsoft's feature; reaches general availability when Microsoft's does.

Read + save forms to Dataverse

Build pages that load records from any Dataverse table and persist user edits back with a single save call. The framework handles dirty tracking, lookup resolution, related-record updates, and the FetchXML/Web API plumbing under the hood—so a typical edit page is a handful of declarative components, not pages of hand-written CRUD wired against the Dataverse SDK.

Validation that matches Dataverse

Required flags, min/max ranges, length limits, and option-set constraints flow straight from Dataverse metadata into the editors, so forms reject invalid input the same way Dataverse would on the server. No duplicate validation rules to maintain in two places—change a constraint in Dataverse and the portal enforces the new behavior on the next page load.

Portal roles, assigned in Dataverse

Bind permission providers to a role name in code, and an administrator decides who holds it by assigning a Portal Role record in the model-driven app — so granting or revoking someone's access is a data change, with no rebuild and no redeploy. A user's access is every role they hold, combined, and roles only ever add. Which roles a newly registered user starts with is data too: pair a role with an assignment mode, or with FetchXML describing who qualifies.

Column-level security

Say which columns a user may read and which they may write, independently — so show the credit limit, don't let them change it is one line. Reads are never rejected over a column: every reference to a withheld column is dropped from the query and stripped from the record, so a view shared by several audiences keeps working. Writes are the opposite — a save touching a column outside the write set is rejected rather than quietly trimmed.

Core controls included

The building blocks for a complete Dataverse portal — editors and rich text, grids, Kanban boards, calendars, maps, search, file viewing, charts and Power BI, timelines, action buttons, layout, and theming — available for both React and Blazor.

How it works

A clean flow from Dataverse metadata to a polished, working portal page.

1) Point at your table/columns

Bind editors to Dataverse entities and attributes (columns).

2) Let metadata drive the UI

Editors pull label/tooltips and enforce required + constraints automatically.

3) Save back to Dataverse

Submit changes reliably with patterns that match Dataverse expectations.

Power Portals Pro vs Power Pages

Both build portals on Dataverse — here's how they compare.

Feature Power Portals Pro Power Pages
Technology React (Vite SPA) or Blazor (Server, WebAssembly, or Auto) — C# + TypeScript Low-code / Liquid templates
UI Framework Microsoft Fluent UI (React & Blazor) Bootstrap (customizable)
Hosting Self-hosted (Azure, any cloud), or hosted by us with Full Service Microsoft-hosted
Source Control Full codebase in Git Configuration-based
AI Agent Support ✓ AI-first: an MCP server with the component API, samples and your own Dataverse metadata, and agent skills in every project ✗ (no equivalent for portal components)
Form Components Metadata-driven typed editors Visual form designer
Data Grids MainGrid & SubGrid with inline editing, views, paging Lists with basic configuration
Charts ✓ Theme-aware charts with Dataverse data sources, click events, aggregates Model-driven app charts through a Liquid tag
Power BI ✓ Reports, pages, dashboards and tiles in the portal's colors, filtered to each viewer's rows, and set up end to end by the MCP server Power BI component, with row-level security roles entered on each one
Calendars ✓ Day, week, month and agenda over any tables, editable, with saved views List calendar view of one table
Kanban Boards ✓ Drag-and-drop boards that save each move and close records ✗
Multi-Table Search ✓ Several tables at once, ranked by best match, with highlights and saved views ✓ Global search across configured tables
Maps ✓ Several tables on Azure Maps, Esri, Google or OpenStreetMap, with geocoding List map view of one table on Bing Maps
Transactional Saves ✓ Multi-record atomic transactions ✗
Record-Level Security ✓ One provider per table — operations, columns, and rows Table permissions (config-based)
Column-Level Security ✓ Independent read and write sets, per table, per user Via Dataverse column security profiles
Internal Portals & Sites ✓ Build employee portals, internal tools, and back-office sites where staff sign in as their own Dataverse user — Dataverse security roles enforce access via CallerId impersonation, no parallel identity model needed Designed primarily for external-facing portals — internal staff sign in as Contacts (parallel identity)
Server-Side Interceptors ✓ Before/after hooks on all operations ✗ (requires plugins)
Localization ✓ Full control over tables, columns, views, choices, and custom strings Limited to Dynamics language packs; views and choices difficult to localize
N:N Relationship Editor ✓ ManyToManyLookupEdit component ✗ (requires custom development)
Local Development ✓ Full local dev experience ✗ Requires cloud connection
CI/CD Pipelines ✓ Standard .NET build & deploy Power Platform pipelines
Custom Business Logic C# — unlimited flexibility Power Automate / Plugins
Pricing Model Flat monthly license fee Per-user / per-site with capacity packs

See the full feature-by-feature comparison Why teams choose a Power Pages alternative

Simple pricing

License it for $495 a month and run it yourself, or choose Full Service for $1,495 a month and we host, set up and look after it for you.

Power Portals Pro

Framework + components for Dataverse portals

$495 USD • per month • per portal
  • React & Blazor components based on Fluent UI
  • Editors for common Dataverse field types
  • Grid + sub-grid for related records
  • Interactive charts with Dataverse data sources
  • Metadata-driven labels, tooltips & validation
  • Localization/translation-ready capabilities
  • Unlimited users (no "per user" licensing costs)
Purchase Now

Request a 30 day free trial

Full Service

We host your portal, set it up and keep it running

$1,495 USD • per month • per portal • 12-month term, billed monthly
  • Everything in Power Portals Pro, license included
  • Hosted for you on Microsoft Azure: no Azure subscription or bill of your own
  • 20 hours of initial setup and configuration
  • Up to 5 hours a month for support, changes and maintenance
  • Upgrades, security fixes and Dataverse credentials handled for you
  • Your data stays in your Dataverse; unlimited users
Purchase Now

Requires your own Dataverse environment. Unused support hours don't roll over to the next month.

FAQ

Answers tailored to Dataverse portal builders.

Can I build my portal with an AI coding agent?

Yes — that's how Power Portals Pro is designed to be used. Install the MCP server once, and Claude, GitHub Copilot, Cursor or any other agent that supports MCP can create the project, connect it to your Dataverse environment, secure your tables and add their pages, reading your real schema as it goes. You approve each change to your environment before it is made, and the result is ordinary React or Blazor code in your own repository, which you review like any other.

What does "metadata-driven" mean here?

Editors and grids use Dataverse metadata to configure labels and tooltips, and to enforce constraints like required fields, min/max values, and length limits—so your portal stays consistent with your data model.

What UI technology is it built on?

Power Portals Pro ships as a React + Vite + TypeScript single-page app or as an ASP.NET Core Blazor app. Both are built on Microsoft's Fluent UI design system for a modern, consistent enterprise look and feel, and both expose the same metadata-driven components and Dataverse capabilities.

Does it support related records (sub-grids)?

Yes. The grid component can be configured as a sub-grid to display related records (for example, child contacts on an account).

How do localization and translation work?

The framework includes capabilities that make it easier to design for localization and translation from day one (labels/content can be planned to vary by language and region).

Does Power Portals Pro include authentication and authorization?

Yes — and it supports two audiences out of the box. Internal portals let staff sign in as their own Dataverse systemuser via Microsoft / Entra ID, and Dataverse security roles enforce row-, column-, and business-unit-level access automatically through CallerId impersonation. Customer-facing portals back users with Dataverse contacts and accept local accounts and passkeys plus external providers — Microsoft, Google, and OpenID Connect or SAML 2.0 identity providers — via ASP.NET Core Identity. Both audiences can share a single portal at the same time.

What login providers are supported?

Local accounts (a username and password, or a passkey), Microsoft and Microsoft Entra ID, Google, Facebook, and OpenID Connect or SAML 2.0 identity providers such as Okta, Auth0, Microsoft Entra External ID, a customer's or partner's own Entra tenant, and AD FS. Each OpenID Connect or SAML provider is added in configuration, with no code, and gets its own sign-in button. Each of them is trusted only for the email domains you list for it, so an address anywhere else is confirmed by email before it can sign in to an existing contact.

Can I build an internal portal for my Dataverse users with Power Portals Pro?

Yes — that's a core use case, not an afterthought. Build internal employee portals, departmental tools, or back-office sites where staff sign in as their own Dataverse systemuser via Microsoft / Entra ID. The portal looks up the signed-in user against systemuser.azureactivedirectoryobjectid and, if it resolves, impersonates that user via ServiceClient.CallerId — so Dataverse security roles enforce row-, column-, and business-unit-level access without any portal-side permission code. Your existing Dataverse role assignments are the security model. If no matching systemuser is found, sign-in falls back to the contact-based flow, so the same portal can serve internal staff and external customers at once.

Can admins test the portal as a contact while keeping admin access?

Yes — link a single Microsoft sign-in to both a Dataverse systemuser (your internal account) and a contact (a test record, or your own customer-side record), and the portal will show a chooser on first sign-in and a Switch to contact / Switch to systemuser entry in the profile menu thereafter. This is the standard pattern for verifying the contact-side experience — rendering, hidden toolbar buttons, permission-driven content — without signing out of the admin account. The chooser pick is remembered in a small per-provider-key cookie so subsequent sign-ins go straight to the last-picked identity.

Do we need to enable Power Pages? Are there Power Pages costs?

No. Power Portals Pro does not require Power Pages to be enabled in your environment. Because you're not using Power Pages, there are no Power Pages-related licensing costs.

How is this different from Power Pages?

Power Portals Pro is a React + Blazor framework and component set, built on Fluent UI, for building a custom portal that integrates with Dataverse. It uses ASP.NET Core Identity (users as Contacts, using familiar Contact fields) and does not require Power Pages to be enabled—so you avoid Power Pages licensing costs.

Ready to build Dataverse portals with less plumbing?

Start Power Portals Pro for $495/mo.

Start now

Get in Touch

Whether you're looking for technical support, have a question about licensing, or want to discuss how Power Portals Pro can meet your needs, we're here to help.

Email: For general inquiries, contact us at support@powerportalspro.com

Support Tickets: For technical issues or bug reports, please open a support ticket on our GitHub repository.

We're committed to responding promptly and helping you succeed with Power Portals Pro. For more ways to reach us, visit our Support page.