Fabric Capacities: Diving deep from Mechanics to Strategy

You thought you knew about Fabric Capacities, think again! In this session we'll cover everything related to those capacities that may be very near to your heart, or those capacities that even show up in your nightmares.

Starting slow, we'll quickly burst through the main mechanics of how capacities work and how the utilization of your organization is taxed against your capacity. And yes, it'll require some brain gymnastics, but we'll also smoothen your questions on those pesky CUs and how you should think about them.

After we grasp the basics, we can start to talking about managing these guys. And while that starts with monitoring, the value is really in understanding why bad things always happen specifically to your capacity. Once we understand, we can act reactively or even in real-time. Let's dive in and get a grip together.

From there we shift gears into licensing and strategy. F-SKUs, reservations, autoscale, pause/resume, Copilot capacity, the works. We'll talk about what each one actually costs you, when it pays off, and where the marketing math quietly falls apart. Expect some real numbers, a few breakeven formulas you can do on a napkin, and clear opinions on the patterns that work for a small team versus a fully grown enterprise estate.

The second half is all about automation and governance. Alerting that doesn't cry wolf, surge protection, chargeback you can actually defend, and Infrastructure-as-Code so your capacities stop being snowflakes. We'll also touch isolation strategies (one big capacity or many small ones?), workspace placement, and the operational habits that separate the teams who sleep well from the teams who don't.

By the end of this session you'll walk away with a working mental model of Fabric capacity from CU all the way to cost center, a toolbox of monitoring and automation patterns you can apply on Monday morning, and hopefully one or two fewer nightmares.

This is a deep dive. Bring coffee.

Building Perry: A Persistent AI Knowledge Partner You Actually Use

Most AI assistants start every conversation from zero. No memory of what you discussed last week, no awareness of your priorities, no continuity between sessions. As a Cloud Solution Architect juggling multiple customer engagements, I got tired of explaining myself to a goldfish every morning. So I built one that remembers.

His name is Perry. He's not a product, not a SaaS, not a fancy framework. He's a folder of plain markdown files in a git repo, wired up to GitHub Copilot in agent mode, with a Wiki-style knowledge architecture and a handful of skills that automate the boring parts of my week. He drafts in my voice, challenges my thinking when I'm about to do something dumb, remembers what each customer cares about, and quietly compounds value the longer I use him.

In this session I'll show you how Perry works under the hood, and more importantly, how you could build your own version. We'll cover the architecture (sessions, knowledge, reference, state), the lifecycle that turns a fleeting note into a permanent piece of knowledge, the skills that turn repetitive tasks into one-liners, and the discipline that keeps the whole thing from collapsing under its own weight.

Expect a walkthrough of a real day with Perry: start the session, do some advisory work, checkpoint, end the day, watch the knowledge graph grow. Expect opinions on what makes a good thinking partner versus a glorified autocomplete. And expect a few honest stories about what didn't work, including the parts I had to throw away and rebuild.

You'll leave with a mental model for persistent AI memory, a concrete folder architecture you can copy, and a clear answer to the question: what changes when your AI actually remembers who you are?

Agentic Power BI Development: From PBIP to Pair Programmer

Power BI used to be a tool you clicked your way through. Then PBIP turned your semantic models and reports into plain text (TMDL, JSON), and suddenly an entirely different toolbox showed up at the door: AI agents that can read, write, and reason about your model the same way they reason about code.

This session is about what happens once you let those agents in. Not the marketing kind of "AI in Power BI", but the practical, sometimes scrappy, often surprisingly powerful kind: GitHub Copilot in agent mode, working on your PBIP files, with the right context loaded, the right skills wired up, and the right MCPs connecting it to Fabric.

We'll start with a quick tour of why PBIP matters and what an "agent" actually is in this context. From there we go hands-on. Expect a lot of demos: Copilot writing DAX in TMDL, generating documentation, doing bulk model edits, reviewing pull requests, and chaining all of it together into workflows that feel a lot less like clicking and a lot more like delegating. We'll wire up an MCP so Copilot can talk to Power BI Desktop directly, and we'll show what changes when your agent stops guessing and starts looking things up.

Throughout, we'll keep one question front and center: where does the agent earn its keep, and where is it still happily wrong with confidence? You'll leave with a clear sense of what's real today and a workflow you can replicate on Monday morning.

Insights into Power BI & Fabric Governance, Administration, and Capacity Monitoring

In this training day, we’ll dive into the essentials of effectively governing and managing Power BI/Fabric environments. You will gain insight into key administrative tasks, capacity management, and monitoring best practices to ensure optimal performance and resource utilization within their Fabric deployment.

By the end of this session, you will:
* Understand the role and responsibilities of a Fabric administrator
* Be equipped to manage and optimize Fabric capacities, including using the bursting and smoothing options
* Gain hands-on knowledge of tools such as the Fabric Capacity Metrics App and Admin Monitoring workspace to establish operational efficiency
* Learn about best practices for capacity planning, automation, and cost management in a Fabric deployment
* Walk away with troubleshooting techniques to maintain a high-performing Fabric environment

Topics covered during the day:
* The role of the Fabric Administrator: An overview of the permissions, responsibilities, and tools available to administrators within the Fabric environment
* Admin Monitoring Workspace: Explore the Admin Monitoring workspace to keep track of performance, potential issues, and system health
* Security and Compliance Monitoring: Ensuring compliance and security standards within Fabric, including audit logs
* Understanding Fabric Capacities: Dive into the mechanics of capacity units, resource allocation, and the different capacity management features such as bursting and smoothing
* Capacity Metrics App: Learn to leverage the Capacity Metrics App to gain insights into resource utilization, demand patterns, and allocation
* Capacity Planning and Optimization: Best practices for planning capacity needs and optimizing resources based on organizational demands
* Automation and Alerts: Implementing automated alerts, notifications, and actions based on capacity and usage thresholds
* Troubleshooting and Diagnostics: Identifying and addressing common issues within Fabric environments, focusing on proactive diagnostic tools

Key takeaways:
* Comprehensive understanding of Fabric governance and administration tasks
* Practical skills to manage and monitor performance in Fabric capacities
* Tools for proactive management and troubleshooting
* Strategies for ensuring compliance, security, and cost-efficiency

This session's target audience:
* Fabric Administrators and IT professionals responsible for managing Fabric environments
* IT Managers and leaders interested in governance and capacity planning
* System Analysts and Engineers who want to broaden their skillset and need insights into monitoring and optimization techniques
* Compliance Officers looking to understand Fabric’s audit and monitoring capabilities

This interactive session will provide valuable insights for both new and experienced professionals aiming to streamline governance and optimize the performance of their Fabric environments. There will also be plenty of time to bring your own problems to the table.

Optimizing Your Power BI Workflow with Project Files, Source Control, and TMDL

Imagine you're part of a dynamic analytics team at a rapidly growing tech company. Your team relies heavily on Power BI to create insightful reports and dashboards that drive key business decisions. However, as the volume of data increases and more team members contribute to the projects, you start encountering challenges: messy project files, difficulty in tracking changes, and complex data models that are hard to manage.
One day, your team lead calls a meeting. She shares a story about another department that faced similar issues but managed to turn things around. Their secret? Implementing a structured approach to managing Power BI project files, using source control to track every change, and leveraging Tabular Model Definition Language (TMDL) to handle their complex data models. Inspired, your team decides to adopt these practices.
Fast forward a few months, and your team's workflow has transformed. Projects are well-organized, changes are easily tracked, and data models are efficiently managed. Reports are more accurate, collaboration is smoother, and your team's productivity has soared. This presentation will guide you through these strategies, showing you how to replicate this success in your own Power BI projects.

In this session, I will guide you through these strategies, demonstrating how to replicate this success in your own Power BI projects.
By the end of this session, you will be equipped with practical knowledge and tools to optimize their Power BI workflows, ensuring their data analytics projects are well-organized, versioned, and scalable.
We will start with a regular PBIX-file and gradually transform it into an organized, versioned model. Using Visual Studio Code, we will set up source control in Azure DevOps with the PBIP-format, apply TMDL and eventually integrate Git into the workspace.
Note: This session assumes a basic understanding of Power BI. Fundamentals of source control and branching will not be covered.

Fabric Capacity Metrics Demystified

In the world of Power BI and Fabric we talk a lot about capacities, whether it's Premium Capacities or Fabric Capacities. However, when working on Power BI or Fabric these capacities often remain a bit unknown. How do they actually work? You've heard of this concept called 'bursting', what does that actually mean? How do you know if you're not paying too much for your capacity?

In this session, I will take you through the ins-and-outs of your capacity(ies). Starting with some key concepts on capacities and how they work, we'll quickly dive into how they operate and how your usage is actually charged to your capacity. Finally we'll look into some practical examples on managing your capacity, leveraging the Fabric REST APIs and Semantic Link to some really cool stuff.

This session is mainly geared towards Fabric and/or Capacity Administrators, though a better understanding of capacities and how they work will also help content creators in developing more efficient solutions. The session requires no prior knowledge, though some familiarity with capacities and/or the Capacity Metrics App will definitely lead to you getting more value out of this session.

Notebooks in Fabric: why Power BI Developer should care (greatly)

By heart, I'm a developer in Power BI, focusing on semantic models. I speak DAX and M fluently (okay, fairly fluent). I started in data with T SQL. So, when notebooks using Spark were introduced with Microsoft Fabric I didn't see how that would influence my day-to-day all to much. Man, how wrong was I..

Built into Fabric Notebooks is a feature called 'Semantic Link'. This feature enables notebooks to connect to semantic models living within your environment. Even more, using notebooks you can interact with these semantic models. For example, you can run DAX queries against the model to extract data. You can also access the XMLA endpoint or call on APIs to actually make changes to your model. The possibilities are endless!

In this session we'll dive into a number of hands-on examples of notebooks greatly improving the life of the Power BI Developer. Assessing the impact of a change in the semantic model? Checking whether that report aligns with your best practices? Validating your data before after a refresh? Or do you want to monitor the size of your model over time? Everything is possible and I'll show you how! And the best thing is: you barely need to learn yet another programming language!

In this session an introduction of notebooks and the features used will be made. An intermediate knowledge of semantic models is recommended to follow along some of the more deep examples shown.