Skip to content
Artwork for Microsoft Fabric Architecture Podcast
TechnologyBusiness

Microsoft Fabric Architecture Podcast

Matthias Falland

Architecture decisions for Microsoft Fabric. Anonymized real customer scenarios, cost realism, counter-arguments included. Weekly episodes aligned with Fabric Friday recordings.

Play
  • 28 episodes
  • weekly
  • Avg 9 min
  • English
Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • #45
    Today · 8 min

    Five Hundred Rows, Ten Files

    Five hundred rows in a lakehouse, and Git gets ten small files. We pull apart what Fabric's Git integration actually stores, what it leaves behind, and why a branch workspace starts empty.

    • Transcript
    • Chapters
  • #44
    November 6 · 8 min

    Do You Need Purview for a Fabric-Only Estate?

    Purview is a brand and an account — two different purchases. We break down what a Fabric-only tenant already gets from Govern, where native lineage stops, and why buying a Purview account for lakehouse lineage doesn't close the gap.

    • Transcript
    • Chapters
  • #43
    October 30 · 9 min

    A Label Is Not a Lock

    A sensitivity label says Highly Confidential in the header, but inside Fabric it never decides who opens the item. This episode traces where labels actually control access and where the appearance of a lock is just a sign.

    • Transcript
    • Chapters
  • #42
    October 23 · 10 min

    Five Thousand Files From a Blank Report

    Medallion is the recommended design approach for Fabric. It's also one building block out of five, and the one that sends you a maintenance invoice nobody put on the architecture diagram. What the file-count guardrail means for Direct Lake on OneLake, why

    • Transcript
    • Chapters
  • #41
    October 22 · 8 min

    Five Doors and One Credential

    Databricks and Fabric have five integration paths, not one. Each moves data. None moves permissions. We pull apart the one-credential model, the hour-long revoke delay, and the ADLS shortcut that silently bypasses Unity Catalog's row-level security.

    • Transcript
    • Chapters
  • #37
    October 16 · 9 min

    Throttled by Yesterday's Refresh

    Fabric doesn't charge you when work happens — it spreads the cost forward into 2,880 thirty-second timepoints. That one sentence explains every confusing capacity behavior, including why surge protection can reject the SQL it's supposed to protect.

    • Transcript
    • Chapters
  • #38
    October 9 · 8 min

    Your Domain Isn't a Wall

    Fabric domains look like governance boundaries but the documentation says otherwise. We unpack what a domain actually gives you, the default-domain mechanism that's still running in your tenant, and why the label on the cabinet is not the lock.

    • Transcript
    • Chapters
  • #40
    October 6 · 9 min

    Where Do the Columns Come From?

    Cosmos DB has no schema. Delta tables need one. When mirroring bridges the two, the replicator guesses — and the guess only ever widens. We trace where the bytes come from, why renamed properties leave ghost columns full of nulls, and what stop replicatio

    • Transcript
    • Chapters
  • #36
    September 4 · 8 min

    The Permission Split Inside Read-Only

    A workspace carries four boundaries — security, cost, region, lifecycle — and you configured one of them. This episode pulls apart what 'read-only' actually means in Fabric, why OneLake security cannot fence in a Contributor, and the silent security chang

    • Transcript
    • Chapters
  • #35
    August 28 · 8 min

    The Snapshot Locked in a Room

    Graph in Fabric materializes a second copy of your data for traversal. That copy explains the staleness, the rebuild cycle, and the workspace boundary that decides whether graph belongs in your architecture.

    • Transcript
    • Chapters
  • #34
    August 21 · 8 min

    The Radio Button That Decides Your Security Architecture

    A connectivity dialog in Fabric's API for GraphQL looks like a setup step. It quietly decides who needs permissions where, whether row-level security means anything, and whether your production API serves development data after every deployment.

    • Transcript
    • Chapters
  • #33
    August 14 · 8 min

    When Save Grants Permissions You Can't Revoke

    An org app is a Fabric item that manages permissions on other items. We pull apart what it actually propagates, where the abstraction stops, and why some grants outlive the authority that created them.

    • Transcript
    • Chapters
  • #32
    August 7 · 8 min

    Your App Published. Nobody Noticed.

    A Power BI app update succeeds and every consumer sees nothing. The publish boundary copies more than you think, grants less than you expect, and fails without a sound.

    • Transcript
    • Chapters
  • #31
    July 31 · 8 min

    Who Promised That Number?

    A scorecard generates its own semantic model the moment you create it. That second store is why goals go stale, RLS doesn't apply, and the fix is never where people look.

    • Transcript
    • Chapters
  • #30
    July 24 · 8 min

    483 Pages and One Design Decision

    A Power BI report exports one page. A paginated report exports 483. The difference isn't a feature toggle — it's a twenty-year-old design decision that carries no data model. That one fact explains every limit, every timeout, and the render failure your M

    • Transcript
    • Chapters
  • #29
    July 17 · 9 min

    Why Can't I Filter My Dashboard?

    Three things in Fabric share the word 'dashboard.' Only one spans multiple semantic models — and it costs you every filter and every slicer to get there. The architecture of tiles, snapshots, and three different refresh behaviors.

    • Transcript
    • Chapters
  • #28
    July 10 · 9 min

    Your Report Isn't Slow

    Every visual fires a DAX query. Most of them queue. Matthias and Fabia trace where the time actually goes when a Power BI report page opens in Fabric, and why the slow thing is almost never the thing you'd guess.

    • Transcript
    • Chapters
  • #27
    July 3 · 9 min

    When Direct Lake Goes Quiet — Power BI Semantic Models

    Direct Lake promises no refresh and VertiPaq speed at lake scale. But its failure modes are silent — it degrades instead of breaking. We pull apart framing, transcoding, and the fallback tax nobody talks about.

    • Transcript
    • Chapters
  • #26
    June 26 · 8 min

    Why Your Data Agent Gets the Wrong Answer

    The grounding prompt decides everything inside a Fabric data agent, and the single highest-impact factor is the one nobody wants to hear. This episode follows the pipeline from question to query to answer, and finds where accuracy actually lives.

    • Transcript
    • Chapters
  • #25
    June 19 · 9 min

    The Function That Bills by the Row — Fabric AI Functions

    AI Functions let you call GPT from a SELECT statement with no API key. Zero infrastructure — until you check the capacity meter. Two billing streams, no result cache, and a default model eleven days from retirement.

    • Transcript
    • Chapters
Showing 1–20 of 28 episodes