TL;DR
- It begins with Power BI as code: express semantic models and reports as text (TMDL, PBIP) you can parse, validate, diff, and regenerate.
- The hybrid pattern makes it enterprise-grade: AI agents propose; a deterministic core disposes – and keeps working when the AI is unavailable.
- The surface is expanding fast – the Power BI Modeling MCP server and authoring skills today, the Fabric Core MCP Server and Fabric REST APIs across the whole platform.
- Composed and governed, these converge into a Fabric-as-Code engine: one governed control plane for the entire analytics estate.
- The payoff isn’t just automation. It’s elevated experiences – and insight generated beyond the dashboard.
Every durable platform shift begins as a modest reframe. This one starts with a single idea: a Power BI semantic model is not something you assemble in a tool – it is source code.
It starts with Power BI as code
Microsoft Fabric makes that literal today. Semantic models are expressible as TMDL, and reports as the Power BI Project (PBIP) format – human-readable, Git-friendly text. The instant your artifacts become text, the entire discipline of software engineering becomes available to analytics: parse a model into a typed object graph, validate it against rules, diff two versions, generate or modify it programmatically, and round-trip it back to Fabric. Version control, automated testing, code review, CI/CD – none of it was designed for BI, and all of it now applies.
This is Power BI as code, and it is the foundation everything else is built upon.
Why the discipline demands more than a tool
Consider a SaaS provider that embeds Power BI and serves a large customer base on shared Fabric capacity. (An illustrative scenario, not a specific customer.) Every artifact its team hand-crafts is paid for once per tenant – and the costs do not add, they compound. A single silent DAX defect propagates wrong numbers to every customer at once. At scale, the unit of cost is not “per task” but “per task × tenant count.” That economic reality is precisely what elevates automation from a convenience to an imperative.
But automation you cannot trust is worse than none. The architecture that earns an enterprise’s confidence inverts the usual dependency: a deterministic core – pure, testable functions over the Fabric and Power BI REST APIs and the Tabular Object Model – performs the predictable work and validates every write, while an agentic layer contributes design intelligence on top. The governing principle is simple and non-negotiable: the model proposes; the deterministic core disposes. When the AI is unreachable, the platform degrades gracefully to deterministic behavior. That single discipline is what allows AI to operate adjacent to a production system of record without staking reliability on a model’s good day.
Leveraging the expanding surface
Here is what makes this the right moment: you no longer build the intelligence from scratch. Microsoft is shipping the connective tissue.
- Power BI Modeling MCP server exposes semantic-modeling operations to AI agents as typed tools over the Model Context Protocol – agents act through governed contracts, not raw APIs (public preview).
- Skills for Fabric, including the Semantic Model Authoring and Report Authoring skills, encode platform expertise as reusable, versioned capability – so best practice becomes shared code rather than tribal knowledge (preview).
- Fabric Core MCP Server widens the aperture beyond Power BI to the entire platform: a remote endpoint that translates natural language into Fabric API calls while honoring your permissions and security policies (preview).
- Fabric REST APIs provide the deterministic backbone beneath it all – the programmable surface for automating any Fabric process, with a Terraform provider for those who want their estate as declarative infrastructure.
Each of these is a building block. Composed behind one governed service layer – exposed once to humans through a web app and REST, and to agents through MCP – they stop being isolated tools and start behaving like a system.
The Fabric-as-Code engine: a governed control plane where agents propose, a deterministic core validates, and every write is gated to production.
The convergence: a Fabric-as-Code engine
Follow that trajectory and the destination comes into focus. As the deterministic backbone (Fabric REST), the agent-facing surface (Core and Power BI Modeling MCP), the reusable expertise (Skills), and the governance fabric (approval gates, lineage, capacity governance, secretless identity, Git integration, deployment pipelines) converge, they form something greater than the sum of their parts: a Fabric-as-Code engine – a single, governed control plane for the entire analytics estate.
For architects, it means designing analytics platforms the way they design software systems – declaratively, testably, and with governance as a first-class property rather than an afterthought. For designers and developers, it means expressing intent in natural language and having it realized through validated, contract-bound operations. And for business users, it means the experience finally transcends the artifact: instead of navigating dashboards and reports, they converse with governed data agents that reason over trusted models and surface insight on demand.
That last shift is the one worth internalizing. The dashboard was never the goal – it was the interface we had. When the platform itself is code, and agents can reason over it safely, insight is no longer confined to what someone pre-built. It becomes something the system generates, in context, in the moment it is needed. Analytics moves from artifacts you consume to intelligence you converse with.
Where architects begin
The vision is expansive; the on-ramp is incremental.
- Establish Power BI as code – adopt TMDL/PBIP and Fabric Git integration.
- Introduce a deterministic validation gate in CI, promoted through deployment pipelines.
- Bring agents in behind that gate, via the MCP servers and authoring skills.
- Consolidate to one governed service layer – two doors, one brain.
- Extend across the platform with the Fabric REST APIs and the Core MCP Server as your ambitions grow.
The strategic question is no longer whether to admit AI into analytics. It is how to admit it without compromising reliability, governance, or trust. Treat Fabric as code, and that question resolves cleanly.
FAQ
Is “Fabric as Code” available today, or aspirational? The foundation – Power BI as code via TMDL/PBIP, Git integration, and the REST APIs – is generally available now. The agentic surface (MCP servers, authoring skills) is in preview and maturing quickly. The engine is a direction you build toward incrementally, not a product you wait for.
Why insist on a deterministic core if the models are capable? Because trust lives in the critical path. The core delivers repeatable, auditable outcomes and a graceful-degradation path; the agents add judgment atop it. AI-only pipelines fail precisely when reliability matters most.
What does “beyond dashboards” actually mean? Governed conversational data agents that reason over your trusted semantic models and generate insight on demand – so answers are no longer limited to the reports someone anticipated in advance.
Go deeper
- Open-source reference implementation on GitHub: github.com/harryarce/fabric-autopilot – the deterministic cores, the MCP integration, the agent team, and one-command Azure deployment.
- Power BI Modeling MCP server: github.com/microsoft/powerbi-modeling-mcp · Skills for Fabric: github.com/microsoft/skills-for-fabric
- Semantic Model Authoring and Report Authoring skills: Microsoft Learn · Microsoft Learn
- Fabric Core MCP Server and the Fabric REST APIs: Microsoft Learn · Microsoft Learn
If you’re designing the next generation of your analytics platform: what would you automate first – and where do you see insight moving beyond the dashboard? 👇
Harry Arce is a Data & AI Advocate, Microsoft Digital Solutions Engineer (Apps & AI), and Postgrad Data and AI Instructor. He writes “Data & AI – Applied” – data in, intelligence out. Capabilities are generally available unless noted as preview, and the customer scenario is anonymized and illustrative. Portions of this article were drafted with AI assistance and reviewed and verified by the author.
Leave a Reply