• No More Roadblocks: The Complete Guide to Networking in Microsoft Fabric

    Microsoft Fabric has become an exciting option to create a data platform solution in the cloud, but networking can quickly become the thing that slows you down or stops you completely. Whether you're trying to bring data in from a secured source, control what Fabric can reach out to, or lock down who and what can access your Fabric environment, there's a lot to navigate.

    In this session we'll cover the full networking picture in Fabric, both inbound and outbound. We'll start by looking at what tenant and workspace level network settings are available and what implications those settings have. Then we'll dive into how private endpoints and managed private endpoints affect your Fabric environment. The familiar on-prem and virtual network gateways from the Power BI world are a central part in Fabric to reach secured data sources, so we'll check how they fit into Fabric to make a full solution. We will also cover when you can use shortcuts to reach storage services in Azure or other clouds even when networking restrictions are in place, as well as how network limitations affect mirroring.
    We'll also touch on the collaboration side of the picture where we might be faced with needing to meet strict security requirements. Often networking and security teams speak a different language than data people, and knowing how to have that conversation can make or break your project.

    On the way we'll go through the most necessary core concepts regarding networking and DNS so the rest makes sense, and we'll keep things practical with concrete demos throughout. After this session you'll have a full picture of Fabric networking from every angle, and nothing should be out of reach!

    Academy Of Tomorrow (Dijlezaal)
    Mon 09:00 - 10:30
    • Deep-Dive Session (2 * 90-minutes)
    • 300 - Experienced

  • Unlocking Data Insights: A Deep Dive into User-Centered Power BI Report Design

    Drawing inspiration from design thinking principles, I'll guide you through a comprehensive methodology aimed at streamlining the report design process within your organization. By placing the end user squarely at the heart of the design journey, we'll uncover strategies and useful tools to create reports that not only inform but empower decision-making.

    Power Station (Scala)
    Mon 09:00 - 10:30
    • Precon Session (Full Day)
    • 300 - Experienced

  • From Chaos to Control: Orchestrating Lakehouse Workloads in Microsoft Fabric

    You have built a lakehouse in Microsoft Fabric. The notebooks are in place, data is flowing through the layers, and transformations are working. Now comes the hard question: how do you orchestrate it all, reliably, scalably, and in a way that fits real-world workloads?

    Should you use Data Factory pipelines, notebook-driven orchestration, materialized views, or bring in a third-party orchestration tool? Each option has clear strengths, but also trade-offs that can become painful in production if chosen incorrectly.

    In this session, we take a deep, practical dive into the orchestration options available for Fabric lakehouses. We will break down how each approach actually works, where it excels, where it falls short, and, most importantly, when you should use one over the others. Through concrete scenarios and production-proven examples, we will compare orchestration patterns for batch processing, dependencies, retries, monitoring, and operational complexity.

    This is not a theoretical discussion. The session is grounded in real implementations used in production Fabric environments, including the challenges, pitfalls, and lessons learned along the way.

    After attending this session, you will leave with a clear decision framework for choosing the right orchestration strategy for your Fabric lakehouse, confidently and deliberately, rather than by trial and error.

    Vision Dome (Alcazar)
    Mon 09:00 - 10:30
    • Deep-Dive Session (2 * 90-minutes)
    • 300 - Experienced

  • An Introduction to Agentic Development

    It's now possible to use AI and agents to not just chat with your data, but build semantic models, dashboards, and end-to-end data solutions. However, this is an area that's advancing rapidly; it's overwhelming for everyone and difficult to know where to get started. In this session, we'll give you a beginners introduction to using agents for creation experiences so that they can save you time and enable you to do more.

    You can expect:
    - The difference between conversational BI with data agents and Copilot versus agentic development.
    - An introduction to coding agents and the foundational basics of how they work and why they can be valuable (and dangerous if used irresponsibly).
    - Demonstrations of how to use coding agents to work with Power BI items like semantic models and reports, as well as to interface with Fabric.
    - An explanation of the core "building blocks" of effectively using agents and AI, with focus on how to choose the right tools, and curate the right context.
    - A step-by-step walkthrough of how to get started using agents to help you build in Power BI and Fabric.
    - Discussions on the future of business intelligence, knowledge work, and more given the advancing capabilities of agents

    For this session:
    You do not need any experience in using AI or agents, but we recommend a basic familiarity with Claude Code, the PBIP format, Git/GitHub and source control (as well as of course Power BI and the Fabric platform)

    By the end of this session, you will have a solid foundational understanding of agentic development and its value, how you can continue learning and experimenting yourself, and where the future of BI and data analytics might be headed.

    Skyline District (Auditorium)
    Mon 09:00 - 10:30
    • Deep-Dive Session (2 * 90-minutes)
    • 100 - Introduction

  • The Polaris Papers: Inside the Fabric Data Warehouse

    Polaris is the distributed SQL engine behind Fabric Data Warehouse, bringing SQL Server query processing into a stateless architecture over OneLake.

    Based on the Polaris papers, this session explains how T-SQL in SQL Pools is compiled by the Front End nodes, optimized into distributed physical plans, orchestrated by the Distributed Computing Platform as workflow DAGs, and executed by Back End compute nodes over data cells. We connect that engine design to Parquet storage, Delta Lake log publishing, query decorrelation, and snapshot isolation, and show what it means for data movement, concurrency, plan quality, and performance at scale.

    Mobility Hub (Herten Aas)
    Mon 09:00 - 10:30
    • Deep-Dive Session (2 * 90-minutes)
    • 500 - Guru

  • SQL Performance Pitfalls: Identification and Optimization Lab

    This interactive workshop presents realistic examples of bad SQL programming that often lead to performance problems in practice. The aim of the session is to show participants how to identify, analyze and optimize inefficient SQL queries/SQL code in order to achieve significant performance improvements.
    The workshop focuses on five to ten concrete, poorly implemented SQL coding scenarios. For each of these scenarios, the underlying problems are explained in detail and optimization approaches are then presented. Different techniques and best practices are presented that are essential for improving query speed and system efficiency.
    With the help of practical lab exercises, load tests are generated to measurably compare performance before and after optimization. This allows participants to directly understand which measures lead to a significant reduction in response times and what impact they have on the overall system load.
    At the end of the session, participants will have a better understanding of the most common pitfalls in SQL programming practices and will be able to perform in-depth performance analyses and make optimizations.

    Control Tower (Begijnenzolder)
    Mon 09:00 - 10:30
    • Precon Session (Full Day)
    • 200 - Intermediate

  • SQL Server 2025 Deep Dive: Engine Performance and Modern T-SQL

    SQL Server 2025 introduces significant improvements for both database professionals responsible for performance and developers building modern data applications.

    This two-part deep-dive session focuses on two of the most practical areas of the release: engine and performance enhancements for DBAs and T-SQL innovations for database developers.

    Across two focused 90-minute modules, we will examine how the new capabilities work, where they provide measurable value, and what they mean for existing SQL Server workloads.

    Part 1: Engine and Performance Enhancements for DBAs.
    The first session explores the SQL Server 2025 engine improvements designed to increase performance, concurrency, observability, and operational reliability. We will look beyond the versions feature list and examine how these changes affect real workloads, troubleshooting practices, and existing performance-tuning strategies.

    Part 2: T-SQL and Developer Innovations
    The second session focuses on the new language and integration capabilities that make SQL Server development more expressive, productive, and better aligned with modern application requirements.
    The demonstrations will compare traditional approaches with the new SQL Server 2025 capabilities, helping participants identify where existing code can be simplified or modernized.

    Whether you are a DBA responsible for performance and reliability, a database developer maintaining complex T-SQL solutions, or an architect planning the next generation of SQL Server workloads, these sessions will provide a practical understanding of the SQL Server 2025 features most relevant to day-to-day database work.

    Academy Of Tomorrow (Dijlezaal)
    Mon 13:30 - 15:00
    • Deep-Dive Session (2 * 90-minutes)
    • 300 - Experienced

  • Master Power BI Refresh Optimisations and Metadata-Driven Frameworks in Fabric

    This session explains enhanced refresh techniques in Power BI, extending with end-to-end enterprise grade metadata driven pipelines in Fabric. It is suitable for aspiring data analysts and Power BI engineers looking to improve their ability to design scalable, flexible, and maintainable data solutions.

    First, we will cover enhanced refreshes and partitions in Power BI. This is needed for incremental or custom refresh patterns. Next we will deconstruct the refresh process, learning how to measure and optimise it.

    After this, we will learn how to build a metadata-driven framework using Fabric. This uses an external data source, such as a SQL table or a JSON file to dynamically control the pipeline behaviour, rather than hardcoding those details. This is key for enterprise solutions as it reduces duplication, improves scalability, and simplifies maintenance. We will then use this pipeline to send requests to refresh tables incrementally or full loads. We can also send custom requests to refresh only specific tables end-to-end, including source loads, transformations, and loading to the Power BI semantic model.

    Audience:
    • BI/SQL Professionals looking to broaden their knowledge of data engineering.
    • Data Analysts seeking to deepen their understanding of data architecture.
    • Power BI Engineers aiming to master scalable data pipeline architectures.

    Prerequisites:
    Basic familiarity with Power BI, Fabric, Pipelines, and fundamental data engineering principles. Knowledge of Python or SQL is helpful but not mandatory. All topics will be explained clearly and advanced knowledge of any tool is not needed.

    Power Station (Scala)
    Mon 13:30 - 15:00
    • Deep-Dive Session (2 * 90-minutes)
    • 400 - Advanced / Expert

  • Practical lessons in optimizing Data Engineering - Spark and Delta

    Based on experience working with some of the largest Microsoft Fabric deployments, this session walks through practical tips for optimising data engineering-focused Fabric environments. This is a demo-centric session — real-world examples of tradeoffs that occur at scale and how simple changes can have outsized impact.

    Through-out this live demo-rich session we will explore the following topics

    Part 1 — Delta as the Table Format
    Delta is Fabric's primary table format, but its features come with performance tradeoffs that only surface at scale:
    - The real impact of Change Data Feed, Delete Vectors, and Deletion Vectors on read/write performance
    - What's coming in Delta 4.0 with the Fabric 2.0 runtime — and what to prepare for now
    - How metadata tables and logging tables in Delta quietly degrade performance — and practical solutions to contain the problem

    Part 2 — Optimising Spark
    Beyond the table format, Spark execution in Fabric has its own set of levers:
    - Orchestrating for scale: minimising cold-start time and session overhead
    - Spark Job Definitions and the Livy API: a walkthrough and demo of developer-centric execution patterns that bypass notebook limitations
    • Unlocking scenarios with notebookutils: parameterisation, chaining, and cross-item orchestration
    • Native Execution Engine: how it works under the hood, when it accelerates your workloads, and when it won't help

    You'll leave with concrete changes you can apply to your Fabric workloads to optimize performance and cost.

    A strong knowledge of Fabric is necessary, a good knowledge of Spark and Delta is highly recommended, with basic knowledge and experience a necessity.

    Vision Dome (Alcazar)
    Mon 13:30 - 15:00
    • Deep-Dive Session (2 * 90-minutes)
    • 400 - Advanced / Expert

  • Semantic Model Catch-Up

    Semantic models are the basis for Power BI reporting. If you already know the basics on building these semantic models, but you want to get up-to-date with more recent improvements, then this session brings you up to speed.

    Calendars in semantic models had issues with weeks, irregulars calendars etc. But the new calendar-based time intelligence can fix these frustrations.

    DAX measures are written such that they can be reused in every visual. But writing these very generic measures could be challenging. With Visual Calculations, you can write measures that are specific to one visual, but this makes for instance a percentage of parent formula a lot more easy to write.

    Ever got frustrated because of a missing DAX function? Why not write it yourself! With DAX user-defined functions, you can write and reuse your own parameterized DAX functions.

    In 3 hours, you will be brought up-to-speed with these advances in Fabric Power Bi Semantic Models.

    Skyline District (Auditorium)
    Mon 13:30 - 15:00
    • Precon Session (Full Day)
    • 300 - Experienced

  • 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.

    Mobility Hub (Herten Aas)
    Mon 13:30 - 15:00
    • Deep-Dive Session (2 * 90-minutes)
    • 400 - Advanced / Expert

  • Prompt-and-Pray Is Not an Architecture: Governing AI in Production Systems

    Abstract
    Building a deterministic delivery model around a probabilistic component is the central architectural challenge of using LLMs in production.
    In this session, I present a governed pattern where the LLM is constrained to produce structured, schema-bound change proposals inside a host framework. Those proposals are validated, reviewed, and only applied after explicit approval. The LLM becomes a contributor, not an executor.
    I will cover why curated admissible context can outperform agentic discovery in high-control environments, why markdown is a weak control surface for precision work, and how validation gates and typed outputs and artefacts change the reliability profile of LLM-assisted delivery.
    This session is for architects, data engineers, and technical leads who want a rigorous, implementable way to use LLMs in production without treating them as autonomous actors.

    *This talk would work well as a two-session deep dive — one covering the methodology, one showing development using it. In that case the second session would be titled "Governed AI Delivery in Practice".

    Control Tower (Begijnenzolder)
    Mon 13:30 - 15:00
    • Deep-Dive Session (2 * 90-minutes)
    • 200 - Intermediate

  • Power BI Unlocked: Vision, Innovation, and What's Next

    Power BI empowers organizations to turn insights into actions and deliver enterprise analytics at scale in Fabric. In this session discover why businesses standardize on Power BI, learn about building a data-driven culture, and get a first look at upcoming features that unlock your data’s potential.

    Skyline District (Auditorium)
    Tue 09:00 - 09:45
    • Session (60 mins)
    • 200 - Intermediate

  • The Dead Horse Theory: A Change Management Survival Guide for Data & AI Professionals

    You poured weeks into building the perfect solution. The data platform is live, the reports are polished, the AI model is ready. And then nothing happens. Your end-users keep copy-pasting numbers into the same Excel workbook they've been nursing since 2017. As data and AI professionals, few things are more frustrating than watching your hard work being ignored. This talk is about understanding why that happens and what you can do about it.

    The answer lies in the Dead Horse theory: when you realize you're riding a dead horse, the best strategy is to dismount. Simple advice, yet incredibly hard to follow. People raised those horses. They know every quirk and every shortcut by heart. No amount of better technology will convince them to let go if they have no reason to change. The real challenge is almost never technical. It's about people, habits, and the absence of a shared vision.

    Drawing from my own experience in data and AI transformation programs, I walk you through the Dead Horse theory in action. You'll recognize the workarounds teams invent to avoid new ways of working, understand why each one fails, and learn how combining a clear future vision with practical change management turns resistance into momentum.

    To make sure this survival guide sticks, I use a structured visual framework built around horses, unicorns, ponies, and foals. Each character represents a recognizable stage in the change journey, giving you a memorable model you can apply immediately. You'll leave with clear anti-patterns you can spot on Monday morning, a practical framework for navigating resistance, and the confidence to help your team finally dismount.

    Academy Of Tomorrow (Dijlezaal)
    Tue 10:10 - 11:10
    • Session (60 mins)
    • 100 - Introduction

  • Beyond Source Control: Using GitHub Projects to plan and execute your data projects

    GitHub is no longer just a platform for source control — it has evolved into a powerful collaboration and project management tool as well.

    In this session, we’ll explore how GitHub Projects can help organize your teams work and plans, improve collaboration, and create more transparant progress reports. In addition, we will also identify other areas where Github Projects can improve feedback loops from end users and improve time efficiency both for the developers and the project team lead.

    Let's jump in with both feet and get your team started with GitHub Projects!

    Power Station (Scala)
    Tue 10:10 - 11:10
    • Session (60 mins)
    • 200 - Intermediate

  • Cut Costs, Boost Speed: Optimising Your Azure Databricks Lakehouse

    Modern data platforms promise scalability and flexibility—but without careful optimisation, costs can spiral and performance can degrade. This session focuses on how to effectively optimise your Azure Databricks Lakehouse to deliver faster data pipelines while significantly reducing platform costs.
    The intent of this session is to provide a practical, experience-led view of how data engineers can design, build, and operate efficient lakehouse architectures. I will explore common inefficiencies across storage, compute, and pipeline design, and show how small changes in approach can unlock major gains in performance and cost control.
    Key topics will include optimising Delta Lake storage patterns, improving Spark workload performance, right-sizing clusters, and making effective use of Databricks features such as Photon, caching, and job orchestration. I will also cover how to design pipelines with efficiency in mind from the outset, rather than retrofitting optimisations later.
    In addition, I will discuss how governance and observability play a critical role in cost management, helping teams understand where spend is occurring and how to control it without slowing down innovation.
    Attendees will leave with practical techniques, patterns, and best practices they can immediately apply to make their Databricks environments faster, more reliable, and more cost-efficient.

    Vision Dome (Alcazar)
    Tue 10:10 - 11:10
    • Session (60 mins)
    • 200 - Intermediate

  • From Fast to Massive: Scaling Power BI to Hundreds of Users with DirectQuery & Fabric Data Warehouse

    What happens when “fast enough” isn’t enough? We follow a real-world journey from import mode to Direct Lake—and beyond. Learn where each approach hits its limits and why DirectQuery to a Fabric Data Warehouse became essential to support hundreds of concurrent users. We’ll share the design changes, trade-offs, and lessons that made this solution scale in production.

    Skyline District (Auditorium)
    Tue 10:10 - 11:10
    • Session (60 mins)
    • 300 - Experienced

  • From Tables to Streams: Rethinking Data Change in SQL Server 2025

    Change Event Feed in SQL Server 2025 introduces a new, event-driven way to capture data changes. It promises to move SQL Server from a system you poll to one that emits change events.

    But what should we realistically expect from it?

    How does it relate to the transaction log?
    What are the implications for throughput and scaling?
    What dependencies does it introduce on the source database?
    And how does it compare to established approaches like CDC when used in real systems?

    This session takes a practical, technically grounded look at Change Event Feed, focusing on what matters when evaluating and planning for its adoption. Rather than treating it as just a new feature, we examine how it fits into the existing SQL Server architecture and what we can infer from that about its behavior, guarantees, and limitations.

    We will explore likely performance characteristics, operational considerations, and integration patterns with downstream systems, including modern data platforms such as Microsoft Fabric.

    The goal is to equip you with a clear, realistic understanding of Change Event Feed so you can ask the right questions, avoid incorrect assumptions, and make informed decisions about if and when to introduce it into your data platform.

    Mobility Hub (Herten Aas)
    Tue 10:10 - 11:10
    • Session (60 mins)
    • 300 - Experienced

  • From Convenience to Control: Breaking Free from Big Tech Data Platforms

    Many modern data platform infrastructures - like those you can build in Microsoft Azure or directly use like Microsoft Fabric - offer convenience, require less technical know-how, and provide direct integrations into other services. At the same time, they also create large dependencies on their platforms that are deeply rooted and difficult to break.

    However, with the current geopolitical climate and tensions between the US and Europe, many European organisations are questioning what it really means to rely heavily on US-based technology and are looking for ways to break away from those dependencies and move towards more digitally sovereign solutions.

    In this session we are focusing on a practical path forward: how to migrate from Microsoft Azure and Fabric towards a sovereign data platform that is fully in control of your organisation and at the same time complies with all relevant European legislation.

    We will map existing Microsoft components to open-source or European alternatives, design an architecture that is open, modular, controllable, and vendor-independent, and of course, discuss the trade-offs involved in moving away from Big Tech data platforms.

    Instead of a theoretical discussion, this talk dives into real-world migration strategies and lessons learned from helping organisations move towards a data platform infrastructure without dependencies and fully in their own control.

    Control Tower (Begijnenzolder)
    Tue 10:10 - 11:10
    • Session (60 mins)
    • 300 - Experienced

  • Geo-Intelligence: Unlocking Insights Through Open-Source Geospatial Analytics

    Most businesses have a geolocation component, think of tracking a runners club to show progress, optimized delivery routes or finding the perfect location for your next store. When implemented effectively, geospatial data can drive growth and open up new strategic opportunities.

    The talk will walk you through the full lifecycle of geospatial data developments with open-source tools—from preprocessing GPS signals with Kalman filters to SQL processing using PostGIS in PostgreSQL databases. You will learn how to analyze and transform data in Python using GeoPandas, the geospatial extension of Pandas. When the data is ready, you’ll see how to visualize geospatial data using Python libraries such as Folium and the open-source tool QGIS. You will also learn how to use unsupervised machine learning models to segment geospatial time-series and classify, for example, the types of movement.

    In the demo, we will show step-by-step a geospatial pipeline that transforms a the GPS trace of a runner & cyclist into processed insights. We’ll learn how to visualize and manipulate geospatial data in QGIS.

    Safety Institute (Verloren Zoon)
    Tue 10:10 - 11:10
    • Session (60 mins)
    • 200 - Intermediate

  • A Practical Guide to the Databricks Analytics Experience

    In this session we will take a tour through the user-facing side of Databricks - the analytics and consumption tools that sit on top of the Lakehouse.

    From the SQL editor and Unity Catalog to AI/BI dashboards, Genie, and Databricks One, the talk covers how these tools fit together and how the platform has evolved to serve everyone from data engineers to business users.

    A practical and honest look at where Databricks stands today as an end-to-end analytics platform.

    Academy Of Tomorrow (Dijlezaal)
    Tue 11:30 - 12:30
    • Session (60 mins)
    • 100 - Introduction

  • Switching from T-SQL to Spark SQL

    You have used Microsoft SQL Server for years to build your BI infrastructure, but now your company starts using Spark. And when you start migrating your T-SQL scripts to Spark SQL you notice that there is more frustration than just the lack of a TOP clause. No IDENTITY columns, no foreign keys, different data types, ...
    In this session you will see which options Spark SQL has for the T-SQL features many need to setup their ELT in Spark, making you ready to migrate!

    Power Station (Scala)
    Tue 11:30 - 12:30
    • Session (60 mins)
    • 300 - Experienced

  • OneLake Security: Building a Unified Security Model Across Your Microsoft Fabric Data Estate

    In this session, we'll explore how OneLake security transforms data governance through a unified, bottom-up security approach. Learn how this solution addresses previous limitations and provides consistent security across your entire data estate.

    Agenda:

    • Historical challenges with Fabric security implementation
    • Limitations of previous security models
    • Introduction to OneLake security architecture
    • How OneLake security resolves inherited vs. overwritten permissions
    • Administrative benefits and simplified governance
    • Business value across organizations of all sizes

    Prior to OneLake security, Microsoft Fabric users faced significant challenges implementing consistent Row-Level Security (RLS) and Object-Level Security (OLS) across their data estates. Despite Fabric's promise to unify the data analytics experience, security remained siloed between different Fabric components, creating confusion about inheritance patterns and best practices throughout the data lineage.

    OneLake security addresses these challenges by implementing a logical, unified security model compatible with all Fabric engines. As a single hierarchical file storage system, OneLake eliminates data duplication and establishes a true bottom-up security approach where permissions configured at the data lake level cascade through the entire system to the end user.

    This session demonstrates how organizations can now centrally configure and manage RLS and OLS on structured data at the foundation level, with all Fabric items inheriting these rules consistently. We'll examine the practical implementation of this model, explore real-world benefits, and demonstrate how OneLake security delivers value for organizations of all sizes by simplifying administration while strengthening data governance.

    Vision Dome (Alcazar)
    Tue 11:30 - 12:30
    • Session (60 mins)
    • 200 - Intermediate

  • Semantic Models Galore!

    Semantic Models have powered Power BI reporting for the past decade and their role is becoming even more prominent and expanding. Join us to learn how semantic models are evolving to not just to build visually stunning reports but to extend across the BI ecosystem, enabling users and agents with business logic with consistency and reliability.

    Skyline District (Auditorium)
    Tue 11:30 - 12:30
    • Session (60 mins)
    • 200 - Intermediate

  • When AI meets your database: Securing sensitive data in Azure SQL in an AI-driven world

    As AI becomes embedded in every application, protecting sensitive data in Azure SQL is vital. This session explores how to secure sensitive data from AI agents and design a defense-in-depth model using Azure SQL's existing security stack - modern authentication, granular access control, data protection, monitoring, auditing, and more. Learn how to confidently use Azure SQL to power AI applications.

    Mobility Hub (Herten Aas)
    Tue 11:30 - 12:30
    • Session (60 mins)
    • 200 - Intermediate

  • Learning to Read at 35: A Career Switcher's Honest Account of Entering the AI and Data Field

    At 35, I made a decision that felt equal parts terrifying and exciting: I left my career behind and jumped into an AI and data bootcamp with no roadmap and no guarantees. This session is my honest account of what that felt like - the confusion, the exhaustion, the moments of joy when something finally clicked, and the very humbling experience of being a complete beginner again as an adult. It literally felt like learning to read again! But this talk is not just my story. In a field moving faster than anyone can fully keep up with, we are all beginners at something right now - whether you are a seasoned DBA encountering agents for the first time, or an analyst trying to make sense of LLMs. This session is an invitation to reflect on what it means to learn in an era of permanent disruption, and to find peace with not knowing yet. Because the most valuable skill in the age of AI is learning how to learn.

    Control Tower (Begijnenzolder)
    Tue 11:30 - 12:30
    • Session (60 mins)
    • 100 - Introduction

  • Fabric CI/CD Done Right: A Complete Deployment Workflow with fabric-cicd

    The landscape of Microsoft Fabric CI/CD has changed - fabric-cicd is now fully supported. You no longer need to manually wire together REST API calls, manage cross-item dependencies, or reconfigure connections every time something moves between environments. There's now a supported, structured way to do it — and it changes how you should think about delivery in Fabric entirely.

    In this session, we'll walk through a complete end-to-end CI/CD workflow, based on real-world implementations. From Git-integrated Fabric workspaces all the way to automated deployments across development, test, and production. With fabric-cicd as our engine, you'll see how to deploy semantic models, notebooks, and reports in a repeatable and maintainable way — while using deployment parameters to handle the environment-specific configuration that makes real-world pipelines work. We'll tie it all together with Azure DevOps YAML pipelines, showing you how to structure your stages, manage credentials securely, and trigger deployments straight from source control.

    By the end of this session, you'll have a clear blueprint for a modern Fabric CI/CD setup — one built on official tooling, supported open-source libraries, and practices that scale beyond a single workspace or team.

    Safety Institute (Verloren Zoon)
    Tue 11:30 - 12:30
    • Session (60 mins)
    • 300 - Experienced

  • Automating CI/CD processes in Microsoft Fabric: best practices and latest developments

    Join us to explore the latest capabilities in Microsoft Fabric for establishing enterprise-grade release processes. We'll cover the different deployment patterns and tools available to build an end-to-end automated deployments.

    Gain practical insights into optimizing your processes and learn about upcoming advancements in the Fabric platform. Whether you're a seasoned developer or just getting started, this session will equip you with the knowledge to streamline your CI/CD processes in Microsoft Fabric.

    Academy Of Tomorrow (Dijlezaal)
    Tue 13:30 - 14:30
    • Session (60 mins)
    • 200 - Intermediate

  • Securing Your Data Estate with Purview

    As AI adoption grows, so does the importance of strong governance and compliance. Let's explore how Purview can support you Fabric environment!

    We’ll cover key features like Data Loss Prevention (DLP), sensitivity labeling, Insider Risk Management, DSPM, and data access governance trough demos and real world examples. At the end you'll leave with an implementation strategy and know the opportunities to further secure your ecosystem.

    Power Station (Scala)
    Tue 13:30 - 14:30
    • Session (60 mins)
    • 200 - Intermediate

  • Inside a Data Quality Dashboard That Actually Works

    Poor data quality doesn’t just frustrate data teams – it slows processes, creates rework, erodes trust and ultimately costs the business time and money. Many organizations try to solve this with dashboards, yet they often end up as diagnostic tools with little impact on day-to-day work.
    In this session I’ll take you inside the data quality dashboard we built in Power BI at Daikin Europe that actually drives improvement. We’ll break down how we highlighted what truly matters, made prioritization effortless, and supported cleanup with clear context, ownership and accountability.
    You’ll see the design decisions, scoring logic and user experience patterns that encouraged teams to take action, not just observe metrics. I’ll also share the lessons we learned the hard way – working around data model limitations, aligning stakeholders and demonstrating business value.
    By the end you’ll understand how a well-designed dashboard can accelerate data quality improvement across the organization and become a true driver of change, not just another report.

    Vision Dome (Alcazar)
    Tue 13:30 - 14:30
    • Session (60 mins)
    • 200 - Intermediate

  • Beyond Power BI: Building Custom Reports in Fabric with Agents and Code

    Power BI reports are well known and widely used, but sometimes you need more control over layout and interactivity than a standard report page allows. Web based reporting using D3.js or Vega is a mature solution in this area that even predates Power BI, but has been too complex for most teas, requiring specialized skills and resources. However, agents make this faster, easier, and more cost effective. This means that you can build custom, bespoke dashboards with powerful visualizations catered to your specific business needs.

    This session walks through how to build custom web-based dashboards in Microsoft Fabric using coding agents and established libraries. We'll connect to semantic models, query the data, and render it in fully custom HTML interfaces that sit on top of the same trusted models your organization already maintains. You'll see what becomes possible when you're not boxed in by standard visual constraints, formatting limits, or canvas dimensions.

    In this session, we'll
    - Explain what a web-based dashboard is and how it compares to a report from an SSBI tool.
    - Explain how to create one with a coding agent, and how it works.
    - Discuss the benefits and advantages as well as any drawbacks and risks for those thinking to use this approach.
    - Provide you general tips for using AI and agents to build visualizations and dashboards.

    By the end you'll have a clear picture of when reaching for code and agents makes sense, and what the actual implementation path looks like if you decide to try it.

    Familiarity with frontend concepts, coding agents like Claude Code, and visualization in Fabric will help you get the most out of this session.

    Skyline District (Auditorium)
    Tue 13:30 - 14:30
    • Session (60 mins)
    • 300 - Experienced

  • Ethos, Pathos & Logos: Aristotle’s Lesson for Ethical Data Design

    Dashboards are designed to support decision-making, yet many still create confusion instead of clarity. Users question whether they can trust the data, struggle to interpret what they are seeing, or are unintentionally excluded by inaccessible and overly complex designs. When this happens, even technically correct reports can fail to drive meaningful action.

    This session explores how a 2,000-year-old framework from Aristotle can help solve these modern data communication challenges through the principles of Ethos (credibility), Logos (logic), and Pathos (emotion).

    Using real examples, attendees will learn how ethical and transparent design choices strengthen trust in reporting (Ethos), how cognitive and perceptual design principles improve clarity and understanding (Logos), and how accessibility and empathy-driven design create more inclusive experiences that work for a wider audience (Pathos).

    Mobility Hub (Herten Aas)
    Tue 13:30 - 14:30
    • Session (60 mins)
    • 200 - Intermediate

  • Keep Your Friends Close and Your Stakeholders Closer

    It starts with a simple request: “Just a few KPIs in Power BI.”
    But then come the filters, extra tabs, and one more breakdown...

    You deliver it all.
    And still… it barely gets used.

    For many data professionals the focus lies on models, visuals, and performance. But the real challenge is NOT about technology, it is about communication. It is about understanding your stakeholders, managing expectations, and staying connected throughout the process. Even if you have built the perfect data model or report, stakeholders can be the reason that adoption stays low.

    In this session, we explore practical ways to build stronger relationships with stakeholders without losing control of scope or timelines. You will walk away knowing how to:
    • Uncover the real question behind a request
    • Keep your stakeholders engaged and informed
    • Prevent scope creep while staying helpful and collaborative

    Because delivering a dashboard is only the beginning.
    Real value comes from adoption, understanding, and use.

    If you want your dashboards to make an impact, you need to stay close to the people who use them.

    Keep your friends close.
    And your stakeholders even closer.

    Control Tower (Begijnenzolder)
    Tue 13:30 - 14:30
    • Session (60 mins)
    • 100 - Introduction

  • Wrong degree, right mindset: How the Human Sciences belong in data

    As data platforms, like Microsoft Fabric grow more powerful, the need for human centered understanding becomes increasingly important. Yet when you walk into most data teams, you’ll find computer scientists, engineers, and statisticians – but rarely a psychologist, linguist, or sociologist.
    For years, the field has signaled that only STEM profiles belong here, causing bright human sciences graduates to filter themselves out before they even try. I am one of those people who didn’t get the memo.
    With a Master in Psychology, experience in mobile eye tracking research, behavioral experiments, neural network simulations, and statistical analysis in Python and R, I discovered that human sciences training is unexpectedly strong preparation for working on the Microsoft Data & AI Platform. Neural networks are inspired by the brain; language graduates have a head start on LLMs; social science graduates bring years of quantitative analysis and research design. Human sciences graduates work with complex datasets, design privacy aware studies, understand cognitive bias, and translate human behavior into structured hypotheses. These are exactly the skills that separate a Fabric dashboard that informs from one that misleads, an AI feature that gets adopted from one that gets ignored, and a stakeholder conversation that uncovers the real question from one that delivers the wrong report on time.
    By translating technical complexity for stakeholders, supporting responsible AI, and aligning data work with real world human impact, human sciences graduates offer a strategic advantage. This session shows why data teams may be leaving talent on the table.
    Technical skills build the system. Human sciences skills make it useful.

    Safety Institute (Verloren Zoon)
    Tue 13:30 - 14:30
    • Session (60 mins)
    • 100 - Introduction

  • Write Once, Use Everywhere: Falling in Love with DAX User-Defined Functions

    If you’ve ever copied the same piece of DAX logic three times and told yourself “this is fine”… this session is for you.

    User-Defined Functions bring a long-awaited concept to DAX: reusability. Instead of repeating logic across measures (and hoping you remember to update all of them later), you can define it once and use it wherever you need it—like a civilized human being.

    In this session, we’ll explore what User-Defined Functions are, how they work, and why they can dramatically improve the maintainability of your models. We’ll dive into the difference between VAL and EXP inputs (and why that distinction matters more than it first appears), and walk through a series of real-world use cases where UDFs genuinely simplify your life—not just theoretically, but in practice.

    Expect fewer copy-paste crimes, cleaner models, and at least one moment where you rethink how you’ve been writing DAX all along.

    Academy Of Tomorrow (Dijlezaal)
    Tue 14:50 - 15:50
    • Session (60 mins)
    • 200 - Intermediate

  • AI and Data Protection in Today's World: Data Democratization and AI Security in Microsoft

    Organizations generate 328 million terabytes of data every day, as we issue AI to put that data within reach of every employee. The promise of data democratization is faster, and the peril is equally real: shadow AI, ungoverned access, and AI becoming an unintentional data exfiltration vector.
    This session demonstrates an orchestrated way Microsoft's integrated security stack closes that gap. You'll walk through the full Zero Trust data architecture, including identity and access (Entra ID, Conditional Access, PIM) through data classification (Microsoft Purview sensitivity labels and DLP) to cloud app threat detection (Defender for Cloud Apps, Sentinel SIEM). Each layer is grounded in real scenarios: what happens when an employee uploads proprietary data to ChatGPT, when a service principal spikes Azure OpenAI API calls at 2am, or when Copilot is used to summarize fifty Highly Confidential documents in a single session.
    A primary focus will be Shadow AI- the fastest-growing blind spot in enterprise security. You'll see live example dashboards and risk analysis reports from Microsoft Defender for Cloud Apps, including how it discovers and scores unauthorized AI tools across 34,000+ apps, enforces session controls in real time, and feeds incidents directly into Sentinel for automated remediation. You'll leave with a clear-eyed view of the three licensing tiers (O365 Cloud App Security, full MDCA, and the standalone add-on) and what each actually buys you.
    This session will have honest comparisons of where Microsoft excels and where best-of-breed alternatives may fit better.

    Power Station (Scala)
    Tue 14:50 - 15:50
    • Session (60 mins)
    • 300 - Experienced

  • Mastering Fabric Data Agents: From Setup to Success

    Fabric data agent has been available for a while, yet many implementations fall short of expectations. Not because of the technology, but because of weak design, unclear instructions, or poorly prepared data models.

    In this session, you’ll learn how to build high‑quality, trustworthy agents by applying proven design patterns around Agent Instructions, Data Source Instructions, and Verified Answers. We’ll explore how to structure semantic models for AI, route questions intelligently across Lakehouse, Warehouse, Eventhouse, and semantic models, and avoid the most common pitfalls that lead to inconsistent results.

    You’ll also see how to operationalize your agents using the Data Agent SDK for automated creation, updates, and evaluations, including golden‑record testing and diagnostics. After this session, you’ll have a clear blueprint for designing reliable, secure, and well‑adopted Fabric Data Agents—from setup to scalable success.

    Vision Dome (Alcazar)
    Tue 14:50 - 15:50
    • Session (60 mins)
    • 400 - Advanced / Expert

  • Finding Context in a Sprawling Unity Catalog

    Unity Catalog was supposed to solve governance. Two years in, you have governance over an estate nobody understands. You have lineage you can't navigate. Ownership nobody can answer for. Dashboards whose data sources nobody remembers. Then agents arrived, and your estate had to start explaining itself to machines that can't ask follow-up questions. Your agent needs to understand data in context, but you can't even do that yourself. Your Agentic MCP needs an ontology. Your ontology needs you to actually know what's in your estate. So where do you even start?

    This session works through the chain from sprawl to agent-ready estate. We start with what UC sprawl actually looks like and why standard discovery tooling plateaus there. We'll discuss how you put semantic meaning over a sprawling estate, what an ontology over a lakehouse actually needs to contain, and where the design decisions bite. Then we'll look at what's in UC to enable agents, how an agent talks to your data estate, what it needs to know in order to succeed, and what breaks when the ontology underneath is incomplete. We'll run through the tools we build to actually enable this at scale.

    For data platform leads, architects, and governance owners running Databricks estates that have to serve agents but can't yet serve their own humans. You'll leave with a vocabulary for the sprawl problem, a clear-eyed view of what an ontology over a lakehouse needs to do, and patterns for building the MCP layer your agents will actually need.

    Skyline District (Auditorium)
    Tue 14:50 - 15:50
    • Session (60 mins)
    • 200 - Intermediate

  • Accidental Data Engineer: A DBA’s First Data Pipeline

    As a SQL Server DBA, I found myself helping deliver a client’s first proper analytics platform - replacing fragile, manual reporting with something scalable and sustainable.

    In this talk, I’ll share how I approached that challenge: testing a few different data integration options, leaning heavily on skills I already had, and figuring out how to stitch everything together into a working data pipeline.

    I’ll cover the architecture decisions, the trade-offs involved, and what I learned moving from database administration into data engineering work along the way - including a first look at some modern data engineering tools.

    This session is aimed at anyone with little to no data engineering experience who wants an honest, practical introduction to what building a data pipeline actually looks like in the real world.

    Mobility Hub (Herten Aas)
    Tue 14:50 - 15:50
    • Session (60 mins)
    • 100 - Introduction

  • Customer Managed Keys in Microsoft Fabric: What It Actually Does (and Doesn't)

    Customer Managed Keys in Microsoft Fabric went GA in late 2025, giving organisations the option to control their own encryption keys rather than relying on Microsoft-managed defaults. But what does that actually mean in practice?

    This session looks at CMK from a sovereignty and operational perspective, what it covers, what it doesn't, and where regulatory frameworks come into play. We'll walk through the full setup: tenant configuration, Key Vault and Managed HSM options, RBAC roles, and workspace activation, including a live demo. From there, we'll get into the production realities, key rotation timing, the one-hour revocation window, item type limitations, and the trade-offs you take on when your key store becomes a critical dependency.

    Control Tower (Begijnenzolder)
    Tue 14:50 - 15:50
    • Session (60 mins)
    • 200 - Intermediate

  • Modern Data Ingestion Paths in Fabric

    Loading data into Microsoft Fabric sounds simple until you realize you have different tools to choose from. Dataflows, copy activity, copy jobs and notebooks each bring something different to the table, and picking the wrong one can cost you time, flexibility, or maintainability down the line.
    In this session, we'll cut through the confusion and map each method to the scenarios where it truly shines. Whether you're pulling from an API, migrating a database, or setting up recurring loads, you'll leave knowing exactly which tool to reach for and why.

    Safety Institute (Verloren Zoon)
    Tue 14:50 - 15:50
    • Session (60 mins)
    • 200 - Intermediate

  • Data Platform Bingo: Deployment Edition

    An interactive 60-minute session on the failures, fixes, and hard-earned lessons behind modern data delivery.

    The concept is simple: the audience gets a bingo card filled with recognizable data-platform disasters. During the session, two energetic Data Platform MVPs pull scenarios, ask the audience if they have seen them, tell short war stories, and explain what should have happened instead.

    As the audience races to complete their bingo cards, the presenters translate every deployment disaster into a practical Database DevOps lesson. We cover version control, release flow, ownership, automation, approvals, testing, migrations, data movement, performance and, of course, communication.

    This session is part AMA, part technical post-mortem, and part therapy session for data professionals. You will laugh, probably recognize too much, and leave with practical ways to make your next database deployment, data pipeline or platform migration a lot less bingo-worthy.

    Maybe your deployment process felt like a game of chance, but it's now time to stop playing bingo with production and join our session!

    Academy Of Tomorrow (Dijlezaal)
    Tue 16:10 - 17:10
    • Session (60 mins)
    • 200 - Intermediate

  • Beyond Dogma and Chaos: Fit-for-Purpose Data Modeling

    Data Vault. Kimball. Medallion. Domain-driven. Every team building a Lakehouse eventually hits the same fork in the road: how rigorously should we model our data?
    One camp goes strict, layered Data Vault feeding Kimball-style marts. Robust, auditable, future-proof and often painfully slow to deliver business value. The other goes pragmatic: "just ship it" – fast at first, until the lakehouse drowns in duplicated semantic models, conflicting KPI definitions and unmaintainable sprawl. Domain-driven and data mesh thinking sharpens the tension: should each domain pick its own approach, or bow to central standards?
    In our work with organizations across the Microsoft Data & AI ecosystem, the strongest teams refuse to pick a side. They match modelling rigor to the value at stake, and they let AI absorb the cost that made rigorous modelling so expensive in the first place.

    Power Station (Scala)
    Tue 16:10 - 17:10
    • Session (60 mins)
    • 300 - Experienced

  • Beyond Standard Use Cases: Exploring Microsoft Fabric with DOOM and Pokémon

    Retro games may not be the first thing that comes to mind when working with Microsoft Fabric, which is exactly why they make such an interesting lens for exploring it.

    In this session, I will use live demonstrations built around DOOM and Pokémon Yellow to show how Microsoft Fabric behaves in unexpected notebook scenarios, what Python can enable in this environment, and how experimentation can lead to useful technical ideas. What starts as an unusual challenge quickly becomes a practical exploration of platform flexibility, notebook design, and non-traditional ways of working with data inside Fabric.

    The session goes beyond simply running games in Microsoft Fabric Notebooks. Using Pokémon Yellow as an example, I will demonstrate how to decode save files from Lakehouse, transform them into structured data, and send them to Microsoft Fabric Real-Time Intelligence to support real-time dashboard scenarios. I will also show how Fabric Lakehouses can be used to store, manage, and retrieve non-traditional assets within these workflows.

    Vision Dome (Alcazar)
    Tue 16:10 - 17:10
    • Session (60 mins)
    • 300 - Experienced

  • Write-Back in Microsoft Fabric - The Ultimate Showdown

    With the introduction of Fabric Planning in Fabric IQ, we have more ways than ever of enabling write-back for Fabric in the Microsoft ecosystem.

    (1) Fabric Planning directly in Fabric, (2) Translytical Task Flows for Power BI users and (3) Power Apps/Automate in the Power Platform each represent a solution for data entry and record editing directly in your Fabric backend.

    Through practical examples and real-world scenarios, this session outlines and compares each solution on strengths and weaknesses, best practices, architecture differences, skill requirements and costs and limitations.

    After the session, you will be able to select and implement the correct solution for your write-back needs and data entry requirements.

    Skyline District (Auditorium)
    Tue 16:10 - 17:10
    • Session (60 mins)
    • 300 - Experienced

  • Unraveling Networking for Azure Databricks

    Azure Databricks is a great service to build your Lakehouse architecture on, but to figure out which networking capabilities you should enable can be hard to figure out.

    In this session we will take a deep dive to Azure Databricks networking capabilities. We'll start from core Azure networking concepts and move to Azure Databricks specific configurations of secure cluster connectivity and how private endpoints are applied. The distinction between the control plane and compute plane will make it easier to understand the flow of traffic for Databricks. The addition of serverless compute brings in new considerations and we'll end by figuring out how it fits in the picture.

    After this session you'll have a thorough understanding of Azure Databricks networking capabilities and the additional security they can provide.

    Mobility Hub (Herten Aas)
    Tue 16:10 - 17:10
    • Session (60 mins)
    • 300 - Experienced

  • Stop asking AI for answers. Start making it argue with you.

    This is how I refined my session pitches for dataMinds!

    Most people use AI as a faster search box or a polite writing assistant. That is useful, but it leaves a lot of value on the table. In this session, I show how I use multiple AI models as sparring partners for real work: shaping ideas, challenging weak assumptions, improving session submissions, pressure-testing proposals, and finding better angles before something reaches a customer, a boardroom, or a conference committee. You will see a practical workflow where ChatGPT, Claude, Gemini, and the human in the middle each play a different role: generator, critic, editor, challenger, and final decision maker. No hype, no magic prompts, just a repeatable way to think better with AI without outsourcing your judgement.

    Control Tower (Begijnenzolder)
    Tue 16:10 - 17:10
    • Session (60 mins)
    • 100 - Introduction

  • Personalized Semantics with User-Context-Aware calculated columns

    This session shows how to design user-context-aware calculated columns in Power BI using the Expression Context property and DAX functions such as USERCULTURE(), USERPRINCIPALNAME(), USERNAME(), USEROBJECTID(), and CUSTOMDATA(). We will walk through practical personalization and translation scenarios across supported storage modes, including Direct Lake on OneLake, Import, and DirectQuery. The session also clarifies when calculated columns are evaluated, how materialized versus unmaterialized behaviour affects refresh and query performance.

    Safety Institute (Verloren Zoon)
    Tue 16:10 - 17:10
    • Session (60 mins)
    • 300 - Experienced

  • What is new and next for OneLake, the OneDrive for data

    OneLake brings the simplicity of OneDrive and SharePoint to enterprise data, unifying analytics and AI on a single intelligent data lake. In this session, we’ll explore what’s new across storage, the OneLake catalog, and domain-oriented data, along with what’s next, including deeper cross-cloud unification, stronger governance, and AI-ready data by default.

    Skyline District (Auditorium)
    Wed 09:00 - 09:45
    • Session (60 mins)
    • 200 - Intermediate

  • The 'human in the loop' fallacy

    “Human in the loop” sounds like a guardrail, but often acts as a checkbox. As AI systems scale, meaningful oversight becomes impossible and decisions degrade into superficial approval. This talk examines, through examples and anecdotes, why this approach doesn’t hold and how embedding control into systems through contracts and constraints offers a more robust path.

    Academy Of Tomorrow (Dijlezaal)
    Wed 10:10 - 11:10
    • Session (60 mins)
    • 300 - Experienced

  • Microsoft Fabric Platform Governance - Where To Start

    In this session, we will explore the administration of Microsoft Fabric, with a focus on the organisation and management of data storage/compute through the configuration of capacities, domains, data products, environments and workspaces. We will discuss the application of data mesh and data fabric concepts in the context of Microsoft Fabric capabilities, including organising data products for effective delivery to business users. Also, considering how Microsoft Fabric compares to the practices and technical standards we’ve applied in Microsoft Azure over the years, making that shift from PaaS to SaaS, in theory and maybe in practical.

    Additionally, we will explore how to use domains and separate workspaces to serve reports to business users, providing them with the information they need to make informed decisions. Aligning industry governance standards to Microsoft Fabric features and access controls. Join us to learn how to effectively administer Microsoft Fabric beyond the simple Workspaces inherited from Power BI

    Power Station (Scala)
    Wed 10:10 - 11:10
    • Session (60 mins)
    • 200 - Intermediate

  • No More Workspace Wars: Git-Driven Collaboration in Microsoft Fabric

    Tired of developers breaking each other’s workspaces in Microsoft Fabric? You’re not alone.

    In this session, we move beyond ad-hoc collaboration to structured, automated ways of working.

    You’ll learn how to combine Git and CI/CD using GitHub or Azure DevOps with end-to-end feature workflows - from branch creation to fully isolated workspaces, pull request validation, review, and automated teardown.

    We’ll cover real-world pitfalls and proven patterns to enable safe parallel development, reduce conflicts, and scale collaboration across teams with confidence.

    Vision Dome (Alcazar)
    Wed 10:10 - 11:10
    • Session (60 mins)
    • 200 - Intermediate

  • Lakebase: Accelerating Application Development in the Agentic Era

    The rise of AI agents and intelligent applications has fundamentally changed what developers need from their data infrastructure. Modern applications demand low-latency access to operational data, seamless integration with AI models, and the ability to iterate rapidly. All without sacrificing security or governance. Traditional approaches often force developers to manage separate systems, adding complexity and slowing down innovation.

    Lakebase brings a fully managed Postgres database directly into the Databricks ecosystem, enabling developers to build applications with familiar tools while benefiting from native integration with the broader lakehouse architecture. This unified approach eliminates data silos and simplifies the development of intelligent applications that combine transactional workloads with analytics and AI.

    In this session, we will explore how Lakebase transforms the developer experience for building modern data and AI applications. We'll demonstrate how to leverage Lakebase for rapid prototyping, discuss its role in powering agentic workflows that require fast read/write access to structured data, and show how governance is maintained through Unity Catalog integration. Attendees will gain practical insights into accelerating their development cycles and building production-ready applications in the agentic age.

    Skyline District (Auditorium)
    Wed 10:10 - 11:10
    • Session (60 mins)
    • 200 - Intermediate

  • Why Questions Are the New Answers

    We train data professionals to deliver answers: dashboards, queries, models, pipelines. But research in cognitive and educational psychology consistently shows that the quality of the answer is capped by the quality of the question that preceded it.

    In this session, I'll take you on a journey through the psychology of how we build knowledge, and why the questions we ask (or fail to ask) determine how far we grow, both as individuals and as teams. I'll show why the most impactful technical engineers aren't the ones with the best solutions. They're the ones asking the best questions.

    We'll explore a practical framework I use when coaching 20+ technical leads and senior engineers: the Information Ladder. It maps four levels of knowledge, from raw facts (What) to application (How), evaluation (When), and purpose (Why), and reveals why most of our education and onboarding starts at the bottom and rarely makes it to the top.

    More importantly, I'll show you how flipping that ladder changes everything: from how you approach a new data problem, to how you guide a junior colleague, to how you challenge a stakeholder who says "just build me a dashboard."

    You'll leave with a concrete, science-backed method for asking better questions in your data work, in your team, and in your own professional growth.

    Mobility Hub (Herten Aas)
    Wed 10:10 - 11:10
    • Session (60 mins)
    • 100 - Introduction

  • Digital Snake Oil - Data Literacy In An Age Of Easy Answers

    We like to think we're rational. But our brains are pattern-seeking, story-telling machines - and that makes us predictable.
    Every piece of information passes through filters: how it was measured, described, visualized, and interpreted. Each layer loses fidelity. Each layer is exploitable. This session explores that gap, from manipulated axes and cherry-picked data to misleading comparisons and false causation. We'll see how these tricks combine in fake news, where outrage replaces analysis, and how AI is making deception faster, cheaper, and harder to spot.

    But this isn't just a catalogue of tricks. The final part is about fighting back. I will share practical tools for spotting red flags, questioning charts, and building the habit of thinking before reacting.

    Because data literacy isn't a skill you learn once. It's a discipline you practice every time you encounter a number, a chart, or a claim.

    Control Tower (Begijnenzolder)
    Wed 10:10 - 11:10
    • Session (60 mins)
    • 200 - Intermediate

  • Beyond Built-in Mirroring: Mastering Open Mirroring in Fabric

    Microsoft Fabric offers built-in mirroring for a wide variety of sources, replicating data in near real-time to your workspace with almost no effort. But what if your source isn’t supported? Open Mirroring becomes the answer. In this session, you’ll learn how to build ingestion pipelines by writing directly to OneLake, understand the storage contract behind it, and get to know the critical design and pitfalls that determine whether it scales or breaks. By the end, you’ll have a solid grasp of Open Mirroring and how to apply it in your own Fabric projects.

    Safety Institute (Verloren Zoon)
    Wed 10:10 - 11:10
    • Session (60 mins)
    • 300 - Experienced

  • PlatformOps: Governance of Your Azure Data Platform

    ## Overview

    When implementing a data platform on Azure, it's easy to focus solely on technical execution—getting things working during a proof of concept. But as your data platform evolves and matures into a data mesh architecture, effective governance becomes critical. This is where PlatformOps comes in.

    Without proper governance, data platforms quickly become fragmented—with inconsistent deployment practices, security vulnerabilities, duplicated infrastructure code, and compliance gaps. PlatformOps provides the framework to prevent this chaos by establishing standardized processes, automated workflows, and clear ownership boundaries. When governed properly, your platform becomes a reliable, scalable foundation that accelerates development velocity rather than hindering it, ensuring teams can innovate safely while maintaining enterprise-grade quality and security standards.

    This session explores the importance of PlatformOps for governing your Azure Data Platform, with a strong emphasis on standardization and automation as foundational principles. We'll walk through a real-world use case and architecture demonstrating how to implement these principles when building a data platform on Azure Databricks.

    ---

    ## What You'll Learn

    - **Code & Infrastructure Reusability**
    - Leveraging Infrastructure-as-Code (IaC) patterns
    - Building reusable Terraform modules and templates

    - **CI/CD Pipeline Implementation**
    - Automated deployment workflows for data platforms
    - End-to-end pipeline orchestration

    - **Security & Environment Management**
    - Establishing safe, secure production environments
    - Implementing robust development and testing workflows

    - **Azure DevOps + Terraform**
    - The powerful combination for PlatformOps excellence
    - Practical integration patterns and best practices

    ---

    ## Real-World Insights

    We'll share practical lessons learned from actual implementations, including:

    - **Obstacles encountered** during our journey
    - **Solutions and workarounds** that proved effective
    - **Key decisions** that shaped our architecture

    Academy Of Tomorrow (Dijlezaal)
    Wed 11:30 - 12:30
    • Session (60 mins)
    • 400 - Advanced / Expert

  • Report Design With Intent: From Layers to Decisions

    Building a Power BI report is not the hard part. Building one that actually guides people toward a decision, rather than just handing them a pile of numbers, is where most reports fall short.
    In this session we break down report design into layers: from the choices you make around data structure and visual type, through layout and composition, all the way to interaction and how users actually move through a report. Each layer has its own logic, and each one influences what comes next.
    From there we translate design principles like hierarchy, contrast, consistency, and alignment into practical guidance you can apply in Power BI straight away. And we take it one step further: we show you how, by using these layers and principles together, you can deliberately shape what users notice, what they conclude, and what they do next, instead of leaving that up to chance.
    This session is for all Power BI report creators and people that want to learn how to turn raw data into actual structured insights.

    Power Station (Scala)
    Wed 11:30 - 12:30
    • Session (60 mins)
    • 200 - Intermediate

  • Modeling Power BI with Code: Unlocking the Power of Semantic Link

    Ready to build and manage your Power BI data models with code instead of endless clicking? In this hands-on session, you'll get to know Semantic Link – the connection between your Power BI semantic model and programmable workflows in notebooks.

    We’ll start with the basics: what is Semantic Link, and why might you choose it over something like Power Query? Then we’ll dive straight into practice. You’ll learn how to:
    load data from source systems,

    read and explore your semantic model,

    and add new measures, tables, or relationships – all through code.

    Together, we’ll build a complete data model from A to Z using Semantic Link. You’ll see how to structure and automate your modeling process with notebooks, including best practices and common pitfalls.

    This session is perfect for BI professionals, data engineers, and anyone looking to model more efficiently within Power BI, Microsoft Fabric, or Azure Notebooks. By the end, you’ll know exactly how to use Semantic Link to work faster, smarter, and at scale.

    Vision Dome (Alcazar)
    Wed 11:30 - 12:30
    • Session (60 mins)
    • 400 - Advanced / Expert

  • Open interoperability: integrating Azure Databricks and OneLake

    Discover how Microsoft and Databricks are advancing an open lakehouse architecture through interoperability between Azure Databricks and OneLake. This session highlights shared data access, seamless integration, and new capabilities like mirroring, native reads, and upcoming write support, helping you accelerate analytics and AI without duplicating data.

    Skyline District (Auditorium)
    Wed 11:30 - 12:30
    • Session (60 mins)
    • 200 - Intermediate

  • Database Development with a Security-First Mentality

    In today’s increasingly digital world, ensuring the security of data is paramount. This session, will dive into the essential practices and principles of secure SQL Server database development. Attendees will learn how to adopt a proactive approach to database security from the initial stages of development, incorporating best practices to safeguard sensitive information against unauthorized access, data breaches, and malicious attacks.

    The session will explore critical security features within SQL Server, such as encryption, authentication, role-based access control, and auditing. Furthermore, we will address the importance of regular security assessments and continuous monitoring to stay ahead of evolving threats.

    By the end of the presentation, developers will have the knowledge and tools to integrate security seamlessly into the database development lifecycle, ensuring their SQL Server databases are resilient and compliant with industry standards and regulations.

    Mobility Hub (Herten Aas)
    Wed 11:30 - 12:30
    • Session (60 mins)
    • 300 - Experienced

  • The Gym Membership Fallacy: Why Self-Service BI Adoption Fails (and How to Fix It)

    Buying a gym membership doesn’t make you fit.
    Giving everyone Power BI access doesn’t make an organization data-driven.
    Self-service BI adoption fails for a reason nobody talks about: we architect for technical capability but ignore human psychology. The result is predictable — unused licenses, report sprawl, support ticket overload, and eventually a backlash where governance locks everything down and "self-service" becomes "service desk".
    Organizations treat self-service BI like buying gym memberships—sign everyone up, send a welcome email, and assume transformation will happen automatically. But buying equipment doesn't create fitness, and granting access doesn't create capability. Most users face cognitive overload (200 measures in a semantic model equals paralysis), learned helplessness (they've been trained to wait for IT), and fear of "breaking the numbers" that keeps them clicking into Excel instead.
    In most organizations Self-service BI promised democratization. What it delivered is a peloton without a lead rider—everyone pedaling hard, nobody drafting, and the whole team arriving 30% more exhausted than necessary. Your "citizen developers" are rebuilding the same semantic models repeatedly. Your business analysts are reverse-engineering calculations because documentation doesn't exist. Your data engineers are firefighting production issues instead of building reusable patterns.
    In this session, you’ll learn why Centers of Excellence become bottlenecks the moment they stop rotating (your best people burn out, then quit). Why standardized starter templates aren't constraints — they're aerodynamic advantage (teams using them ship 3x faster). And why the gym membership fallacy explains your adoption failure: access doesn't create capability, progressive autonomy does.
    Using behavioral psychology, nudge theory, and real Fabric examples, we’ll explore why self-service environments swing between chaos and lockdown — and how to design safe autonomy instead.
    This isn't another "build a CoE" presentation. This is applied psychology for Microsoft Fabric.

    Control Tower (Begijnenzolder)
    Wed 11:30 - 12:30
    • Session (60 mins)
    • 300 - Experienced

  • Do You Really Need Spark? How to choose the right execution model in Microsoft Fabric

    Spark has become the default choice for data workloads, but distributed compute is not always the right answer.

    In this session we dig into real workloads and compare Spark to native Python head to head. We will walk through scenarios like cleaning and transforming a few million rows, running aggregations on mid-sized datasets, and performing look-ups and joins on reference data. We'll look honestly at where each approach wins and why that is the case. Along the way we'll cover the trade-offs that don't always make it into the documentation: cold start times, debugging overhead, compute costs...

    You will leave this session with:
    - A clear understanding of what Spark is actually optimised for, and what it isn't
    - Practical examples of workloads where native Python outperforms Spark in speed, cost, and simplicity
    - A decision framework you can apply immediately to your own pipelines and notebooks
    The ability to confidently argue on which solution suits which workload

    Whether you're building new solutions in Microsoft Fabric or inheriting ones that already exist, this session will sharpen how you think about execution models and help you make better architectural decisions from now on. You'll spend less time over-engineering, less money on unnecessary compute, and more time delivering solutions that actually fit the problem.

    Safety Institute (Verloren Zoon)
    Wed 11:30 - 12:30
    • Session (60 mins)
    • 300 - Experienced

  • The ultimate decision guide: capacity strategies to optimise cost and compute

    Fabric capacities are still something not easily understood by customers. This decision guide will help you choose the best capacity strategy for your scenario, from a big multi-tenant environment to a single-capacity SME. This will take into account new functionalities such as capacity overage, autoscale billing for Spark, Copilot capacities, and focus on continuously optimising cost and compute in these different scenarios. You leave with a guide you can use in your next customer conversation.

    Academy Of Tomorrow (Dijlezaal)
    Wed 13:30 - 14:30
    • Session (60 mins)
    • 200 - Intermediate

  • Keeping the Fabric factory operational: turning cost knobs and building better monitors

    Saving money in Microsoft Fabric is straightforward when you know the right knobs. Turn them blindly, or miss one entirely, and production can suffer.

    This incident-driven session shares hard learned lessons from real environments: start/stop versus reserved capacity, Spark autoscale and Spark pool tuning, OneLake storage growth, and the monitoring and guardrails that prevent throttling, failed pipelines, and surprise bills. All done within Fabric with built-in tools and custom solutions.

    Power Station (Scala)
    Wed 13:30 - 14:30
    • Session (60 mins)
    • 200 - Intermediate

  • From Notebooks to Living Documentation

    As developers, we all love writing documentation… right?
    Error....

    In reality, notebooks are where the best work happens—and where clarity often goes to die. Inconsistent structure, missing context, half‑explained decisions, and those “temporary” cells that somehow survive every refactor. Revisiting or sharing such notebooks weeks or months later becomes painful, and turning them into usable documentation is usually postponed… indefinitely.

    The intent of this session is to show a practical, repeatable approach to fixing this—by using Generative AI not as a code generator, but as developer assistant that supports both notebook quality and documentation across the software development lifecycle.

    The session demonstrates a workflow where existing analytical and engineering notebooks remain the single source of truth. Using a strong, carefully designed prompt, Generative AI applies consistent review pressure—much like an experienced colleague would during a thorough code review.

    From that reviewed notebook, the session then shows how documentation can be systematically derived, rather than written as a disconnected afterthought. The same source material is translated into multiple documentation layers, each tailored to a specific audience

    This is explicitly not a session about vibe coding or blind AI-driven generation. Human control remains central: developers own the code, the structure, and the final decisions. Generative AI is used to provide consistency, discipline, and scale in review and documentation—without introducing fragile or opaque workflows.

    Vision Dome (Alcazar)
    Wed 13:30 - 14:30
    • Session (60 mins)
    • 300 - Experienced

  • How to make your Power BI Semantic Models faster!

    Tired of the dreaded "this report is slow" feedback? Sluggish reports and long refreshes are often symptoms of unoptimised models or hidden design flaws. In this session, I'll give you the practical toolkit to find and fix them

    In this session I will walk you through how to approach this scenario. We'll identify the cause of poorly performing reports/models and discuss how they can be redesigned or optimised to help improve performance.

    I'll show you how you can use tools like DAX Studio and Tabular Editor to identify and correct issues, leveraging keys features like Best Practice Analyser & VertiPAQ analyser. We'll also dissect some of the most common causes of slow DAX queries & show you how to avoid them.

    You’ll leave this session with the tools and skills to build faster, more efficient models and finally silence the "slow report" complaints.

    Skyline District (Auditorium)
    Wed 13:30 - 14:30
    • Session (60 mins)
    • 300 - Experienced

  • Spice up your SQL - Intro to Window Functions

    Ready to take your SQL skills to the next level? With window functions, you can tackle complex problems in SQL with ease. Running totals? No issue. Removing duplicate values? Eazy peazy. Replacing cursors with a tally table? Donzo. Checking stock values for V-shapes? Okay, that one is a bit more complicated, but it can still be handled with window functions.

    In this session, we introduce you to the awesome world of window functions and explain how they can make your SQL life easier. We'll talk about the various use cases you can solve with them and how you can optimize their performance.

    At the end of the session, you'll have a solid grasp of window functions and know where you can use them in your SQL scripts. Basic SQL knowledge is assumed.

    Mobility Hub (Herten Aas)
    Wed 13:30 - 14:30
    • Session (60 mins)
    • 200 - Intermediate

  • If Your Disaster Recovery Plan Doesn't Cover Panic, It's Fiction

    Every DR plan I have seen boils down to two numbers, RTO and RPO. Both objectives assume the people executing the plan are calm and actually reading the runbook.

    At 3am during a real incident, none of that is true. Ask me how I know!

    Twenty years ago, before I stumbled into data, I worked as a paramedic with the German Red Cross, where I learned about Crisis Resource Management. Aviation built CRM after a run of crashes where the airplanes worked and the teams didn't. Medicine had similar problems and adopted the concepts wholesale.

    In this session we will explore what happens to a human brain under incident pressure, and why runbooks written for calm people fail the moment panic arrives. We will also look at what teams owe each other during and after. We will tackle how to keep the person in charge and the team around them functional when everyone is scared, tired, and can barely see past the next step.

    Whether you carry the pager or own the DR plan, you will leave with a different way of reading it and a handful of named techniques borrowed from a line of work where crisis is daily business. You can start using them Monday morning.

    Control Tower (Begijnenzolder)
    Wed 13:30 - 14:30
    • Session (60 mins)
    • 200 - Intermediate

  • Friends Don't Let Friends Deploy Agents Untested


    Building agents is the part everyone talks about. Testing and monitoring is the part that is rarely covered in demos and tutorials.

    In most teams, checking agent quality looks like this: run the agent, read the output, fix what looks wrong, repeat. Each fix can reintroduce an old bug or a new issue.

    This session covers the full lifecycle of getting an agent to production and keeping it there: how you systematically test a new version before it reaches users, how you monitor quality once it does, how you manage reliability and governance when the underlying models change, and how you handle versioning and the promotion lifecycle. We will even take this one step further by discussing how you can build a self-evolving test harness.

    We'll use practical examples, so you can apply the same patterns when building your own agents, or even for your coding agents.

    Safety Institute (Verloren Zoon)
    Wed 13:30 - 14:30
    • Session (60 mins)
    • 200 - Intermediate

  • Database Unit Testing for Data Professionals

    In traditional software development, Unit Testing is pretty well known. But what about Unit Testing for database solutions?
    Or more specifically, what about Unit testing for Data Warehouse solutions?

    In this session, we will dive into the world of Unit Testing for databases, with a focus on Data Warehousing solutions.
    Before we dive into practical examples, we need to understand the key concepts and the importance of Unit Testing.
    As soon as the basics are set, we will talk about different possibilities/frameworks to implement Unit Testing.

    Near the right before the halfway mark, we will dive into the tSQLt Framework specifically and we will start to get more practical.

    What are we going to discover?
    * How to create 1 or more Test Classes?
    * How to create different Unit tests?
    * What's possible with tSQLt?
    * How to automate your Unit tests?

    If you are wondering how to get started with Unit Testing for Data Warehouse solutions or databases in general this session is for you!

    Academy Of Tomorrow (Dijlezaal)
    Wed 14:50 - 15:50
    • Session (60 mins)
    • 200 - Intermediate

  • From On-Prem SQL Server and dbt Core to Microsoft Fabric and dbt Cloud: A Real-World Migration Story

    Many organizations have built mature analytics platforms on on-premises SQL Server, traditional data warehouse architectures, and dbt Core. Moving these workloads to Microsoft Fabric and dbt Cloud can look straightforward on paper — until existing assumptions about SQL behavior, development workflows, concurrency, testing and operations meet a very different platform.

    In this session, I will share lessons from a real-world migration project in the financial services industry, moving an existing on-premises SQL Server-based data warehouse with dbt Core towards Microsoft Fabric and dbt Cloud. We will look at the architectural decisions involved, the migration path, and what happened when the original migration approach met the realities of the target platform.

    Using concrete examples from the project, we will explore SQL compatibility, Warehouse vs. Lakehouse considerations, CI/CD and incremental model testing, development environments, locking and concurrency behavior, reconciliation, performance, governance and operational readiness. We will also look at how platform limitations and unexpected behavior forced us to adapt parts of the architecture and delivery process.

    Attendees will leave with a realistic view of what such a migration involves, which assumptions should be validated early, where Fabric and dbt Cloud can add value, and which technical and operational pitfalls to consider before starting their own modernization journey.

    Power Station (Scala)
    Wed 14:50 - 15:50
    • Session (60 mins)
    • 300 - Experienced

  • Data Contracts as Code on Azure Databricks

    Data contracts are agreements between the people who produce data (upstream systems, pipelines, teams) and the people who consume it (analytics, machine learning, applications). Data contracts define what a dataset should look like, how fresh it should be, who can access it, and what quality it must meet.

    The problem is that most data contracts in enterprises live in the wrong place: architecture blogs, Confluence pages, YAML files nobody reads after the first sprint. A markdown file that says "order_id must not be null" does not stop a null from being written. A Confluence page that says "this table is updated hourly" does not alert anyone when the pipeline fails.

    This session focuses on the technical enforcement layer of a data contract. Using Azure Databricks Unity Catalog and Lakeflow Spark Declarative Pipelines, I will demonstrate how six of the data contract attributes: schema, quality, usage policies, security, SLAs, and data description can be defined once, enforced automatically, monitored continuously, and versioned alongside your pipeline code in Git.

    At the end of this session, you will leave with a GitHub repository containing contract templates and a practical framework for turning your existing governance policies into objects that Databricks can actually enforce.
    The session is for data engineers and platform teams working with Azure Databricks who want to bring their data contracts into the codebase.

    Vision Dome (Alcazar)
    Wed 14:50 - 15:50
    • Session (60 mins)
    • 200 - Intermediate

  • 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.

    Skyline District (Auditorium)
    Wed 14:50 - 15:50
    • Session (60 mins)
    • 200 - Intermediate

  • Power BI Gateway Logs Unlocked: Find the Clues, Fix the Issues

    On-Premise Data Gateway often feels like the most mysterious part of Power BI. Even its name can mislead, as it's also needed for some cloud sources!

    It seems simple: create a connection, map it to your model, schedule refresh and it usually just works... But have you ever wondered what happens when you click that refresh button? How does your data travel through the Gateway, which hurdles does it need to pass and, more importantly, what traces does it leave behind?

    Don't you worry, after today's session, Gateway will have no secrets for you!

    During these 60 minutes I'll explain how the Gateway works in plain words. Together we'll dive into Gateway logs, discovering valuable insights, practical ways to spot issues and techniques to boost performance. No mystery - just clear, actionable knowledge!

    Mobility Hub (Herten Aas)
    Wed 14:50 - 15:50
    • Session (60 mins)
    • 300 - Experienced

  • When Will It Be Done? Estimating data work when uncertainty is part of the process

    Every data project runs into some version of the same question: “When will it be done?”

    Part of what makes it hard is that data work often reveals the work while you are doing it. You start with a plan, then learn things that change it: the source data is messier than expected, definitions do not match across teams, a join does not behave the way it should, access is missing, or the first results raise a better question than the one you started with. For many data people, that detective work is part of the appeal. It is also what makes a firm date hard to promise too early.

    That does not make data work entirely unpredictable by nature. But it does mean estimates need room to evolve. The easy answer is a single confident date. A more useful answer still helps people plan: it gives the best current estimate, the confidence behind it, and the assumptions that could change it. That way, when the work reveals something new, the timeline can be updated openly instead of turning every new finding into a missed commitment.

    This non-technical, practical session is about estimating and communicating data work without pretending the uncertainty is gone. You will learn how to separate discovery from delivery, estimate in ranges, name the assumptions behind a date, and narrow estimates as the work progresses.

    We will also look at how to give better status updates than “on track,” how to explain what has actually changed, and how to handle stakeholders who still want one fixed number.

    It’s for anyone who has had to put a timeline on data work - whether it’s a dashboard, report, pipeline, model, migration, or AI prototype- while the work was still unfolding.

    Control Tower (Begijnenzolder)
    Wed 14:50 - 15:50
    • Session (60 mins)
    • 200 - Intermediate

  • Scalable Finance Reporting in Power BI & Fabric

    At TriFinance, we are often contacted by the CFO office to assist with there financial/management reporting in Power BI/Fabric. They always struggle to present e.g. a P&L or Cash Flow statement properly in Power BI. During this session, we want to elaborate on our approach to solve this issue and to have a nicely structured Financial Report available. We would like to show different options "from zero to hero" going from dax over ETL logica to custom visuals e.g. Aimplan.

    Safety Institute (Verloren Zoon)
    Wed 14:50 - 15:50
    • Session (60 mins)
    • 200 - Intermediate

  • Designing Efficient Architectures: Best Practices for Governance, Security, and Sharing Policies

    As we journey through designing strategy to implementing policies, we will dive into the creation of process maps and establishing roles and responsibilities through the RACI model. Attendees will gain a comprehensive understanding of the Optimized Architectures Document, which serves as a blueprint for optimizing content delivery infrastructure. Architecture will highlight asset certification and endorsement. On top, we'll see how Fabric architectures contribute and what needs to be included.

    Walk away equipped with a toolkit of proven methodologies and real-world-tested frameworks. Armed with these insights, you'll be poised to not only design but also implement effective and secure content delivery architectures within your organization.

    The session is for those who are responsible for, or involved in, rolling out, governing, or designing Power BI architecture, or interested in expanding their knowledge of Power BI Governance.

    Academy Of Tomorrow (Dijlezaal)
    Wed 16:10 - 17:10
    • Session (60 mins)
    • 200 - Intermediate

  • Roast our Power BI setup: When best practices hit reality

    Almost three years ago, I started as a Power BI coach at a large Belgian organisation. I had never set up a Power BI architecture or built a Power BI community and neither did anyone in the organisation, but regardless, that is exactly what we did.

    As you might guess, we encountered a lot of issues and learned a lot. I could walk you through all those pitfalls and learnings, but to be honest, I would think that's rather boring.

    So instead, I invite you to come and roast our initial setup.

    You point out the flaws, I tell you how we solved them, or didn't.

    Power Station (Scala)
    Wed 16:10 - 17:10
    • Session (60 mins)
    • 100 - Introduction

  • Managing your theme park with analytics: Combining Microsoft Fabric with Rollercoaster Tycoon

    The classic theme park simulation RollerCoaster Tycoon includes many of the challenges we encounter in real-world organizations, such as pricing strategy, predictive maintenance, throughput optimization, and human resource management. Using Microsoft Fabric, we have built an analytics solution that helps us make informed decisions while playing the game.

    Starting from business questions such as “What is the ideal ticket price for this rollercoaster?”, we explore how to approach these challenges analytically. Later on, we dive into the Microsoft Fabric architecture and the technical details behind the setup.

    Vision Dome (Alcazar)
    Wed 16:10 - 17:10
    • Session (60 mins)
    • 200 - Intermediate

  • From Semantic Models to Ontologies: The Missing Layer for Fabric Data Agents

    Fabric Data Agents can query your semantic models, but can they truly understand your business? Semantic models describe the shape of your data, but they don't capture meaning. That missing layer is an ontology.
    This session exposes where agents break down and introduces practical patterns for enriching your semantic layer with ontological metadata: business glossaries, concept hierarchies, relationship semantics, and inference rules.
    Through live demos, you'll see how these enrichments help Data Agents resolve ambiguity, reason across domains, and produce trustworthy answers. You'll leave with a maturity framework and a concrete roadmap to get from "semantic model" to "knowledge layer" without boiling the ocean.

    Skyline District (Auditorium)
    Wed 16:10 - 17:10
    • Session (60 mins)
    • 200 - Intermediate

  • Good dates, bad dates: Mastering your T-SQL date and time datatypes

    Working with date/time datatypes in T-SQL can be quite frustrating if you don’t have the tools and know-how. Let me arm you with all the knowledge you need to correctly model, convert, index and query your date/time data in a logical and easy-to-understand manner.

    We’ll cover the wide range of datatypes available in SQL Server/Azure SQL, and help you understand which ones are right for your goals. We’ll dig in to explicit and implicit conversions, optimal indexing strategies, and some hidden gotchas when working with date/time data.

    For the icing on the cake, we’ll also look at some horrible real-world anti-patterns from the trenches, and how to address them like a pro.

    Mobility Hub (Herten Aas)
    Wed 16:10 - 17:10
    • Session (60 mins)
    • 200 - Intermediate

  • Is this the end of Index Maintenance? Introducing Automatic Index Compaction

    Index maintenance has long been one of the core tasks of every database administrator working with Microsoft SQL Server.

    We rely on scripts scheduled in jobs, running resource-intensive operations during planned maintenance windows to rebuild or reorganize indexes. Then, we need constant monitoring, tuning, and iteration.

    But what if that approach is changing?

    Introducing Automatic Index Compaction, a new SQL Server feature designed to continuously improve the page density of your indexes!

    I see your eyebrow raised! I had a lot of questions too:
    - Does it eliminate the need for REBUILD and/or REORGANIZE the indexes?
    - Is it suitable for all workloads?
    - Does it respect FILL FACTOR?
    - What are the trade-offs in terms of performance, logging, and resource usage?

    Is this the end of long-running index maintenance jobs?

    Join me in this session and let's dive into how Automatic Index Compaction actually works, what problems it solves (and what it doesn’t), and how it can change the way we think about index maintenance.

    By the end of the session, you will understand how it works and whether you should put it in place in your environments.

    Control Tower (Begijnenzolder)
    Wed 16:10 - 17:10
    • Session (60 mins)
    • 300 - Experienced

  • We struggled with Copilot Studio so you don't have to

    Building a Copilot Studio agent is easy. Getting that agent live, trusted by users, and actually embedded in daily operations? That's a different story.

    After deploying Copilot Studio solutions across multiple projects, we learned that the biggest challenge is rarely getting an agent to work. The hard part is making it predictable, explainable, maintainable, and deployable in an enterprise environment without everything turning into chaos after the pilot phase.

    This session is an honest look at what actually separates successful Copilot Studio implementations from the ones users quietly abandon. We’ll go beyond AI hype and focus on the lessons learned the hard way: why the most effective solutions are often not the most agentic ones, why unrestricted environments become impossible to govern, and how to embed this in existing processes to ensure adoption.

    The session covers:
    • Lessons learned:
    What broke, what surprised us, and the decisions we'd make differently.
    • Deterministic vs agentic:
    How to decide which parts of a workflow should stay deterministic, where AI truly adds value, and how both reinforce each other.
    • CI/CD and operational maturity:
    How to use solutions, environments, and deployment pipelines to scale beyond a single environment without losing oversight and maintainability.
    • Tools, subagents, and best practices:
    When subagents improve clarity versus when they only add complexity, how to extend agents through connectors and MCPs, and why topics are more reliable guardrails than prompt instructions alone.

    The session includes a live demo showing how flows, tools, and orchestration can work together in a production-ready Copilot Studio setup.

    By the end of this session, you will know how to structure agents that remain in control, how to deploy Copilot Studio solutions across environments without governance chaos, and how to balance agentic and deterministic design to build solutions that are both powerful and trustworthy.

    Safety Institute (Verloren Zoon)
    Wed 16:10 - 17:10
    • Session (60 mins)
    • 200 - Intermediate
Session and Speaker Management powered by Sessionize.com