Episode 327 – Fabric June 2026 Feature Summary (Part 1)

Episode 327 opens the Fabric June 2026 Feature Summary — and takes a productive detour along the way. Recorded on June 8th, 2026 after a longer-than-usual gap between episodes (graduations, conference prep, and a genuinely relentless news cycle), John and Jason start with a Build recap, then spend a good chunk of the episode on something that isn’t in any blog post: how the GitHub Copilot app and Fabric skills have changed the way they both actually work. The rest of the June summary — Data Warehouse, Real-Time Intelligence, business events, Data Factory, and database apps — is heading for a future episode.

Build 2026: the labs were the story

Neither host attended Build in person this year, but the reports coming back were consistent: the hands-on labs were where the value was. Proctored, well-run, and worth the trip on their own. The keynote ran two and a half hours — long enough that a lot of attendees tapped out partway through — and the venue relied on curtained-off rooms, which shows up as background noise on the session recordings. The content held up, though. The dev machine announcement was interesting (128GB of RAM in a mobile form factor, with battery life claims that will need to be seen to be believed), the “three IQs” positioning still feels a step ahead of where the Copilot integration story actually is, and Hanselman was Hanselman. If you couldn’t attend, the recordings and Learn modules make most of it recoverable — the in-person networking is the part you can’t get back.

The GitHub Copilot app and Fabric skills: the conversation that matters

The most useful stretch of this episode isn’t a feature summary item at all. Both hosts have shifted a significant part of their daily work into the GitHub Copilot app, and the reasoning is worth hearing. John’s description: “It’s like Visual Studio Code without the code.” If you’re using it for interrogation, root cause analysis, prototyping, or straight-up coding and you don’t need to see the files themselves, the app covers it — and it has session management that the VS Code path doesn’t.

That session management matters more than it sounds, and there’s a financial dimension. In VS Code you tend to end up in one very long-running session because you want the context to persist — which drives token consumption up fast. The Copilot app is session-first rather than code-first, and each session gets its own descriptively named branch by default. For teams working under the token-based billing model that took effect June 1st, the difference is real money, not just tidier branches.

Then there’s the Fabric skills story, which John describes as worth screaming from the rooftops. The concrete example: a team was collecting real-time telemetry into a KQL database, using OneLake availability to expose it, then running Spark notebooks to move data from bronze to silver. It worked, but it burned Spark resources for something Event House could do natively — with functions and update policies — faster, cheaper, and in actual real time. The reason they hadn’t was simple and familiar: the people doing the work knew notebooks, not KQL. So John pointed GitHub Copilot with Fabric skills at the notebook and asked it to replicate the logic as functions and update policies across the respective Event Houses. It did it without a flaw, and the pipeline now runs in real time. That’s the shape of the argument for these tools — not that they replace expertise, but that they let the expertise you have reach into the tools you don’t know yet.

Both hosts are clear-eyed about where AI-assisted code fits in their own workflow. Neither is a developer by trade — they’re on the data side. What comes out is proof-of-concept work: functional code and documentation handed to development teams as a working sample, not production code. Verbose by design, pointed at dev data, and explicitly meant to be rebuilt properly downstream. “Here’s how — let me show you it working. This is what I want it to do.”

Fabric Platform: GitHub Enterprise support arrives

The platform section is short but lands well. Workspace source control integration — which already covered Azure DevOps and GitHub — now supports GitHub Enterprise, which is a fundamentally different endpoint. For organizations that have moved wholesale to GitHub Enterprise (and there are a lot of them right now, including Jason’s), this is the difference between Fabric Git integration working and not working. Timely.

OneLake: storage tiers and item size reporting

Two OneLake announcements this month, both in preview, both about storage. The first gives you control over storage tiering. Until now everything sat in the hot tier of the underlying ADLS Gen2 storage whether it needed to or not. You can now set policies to move data between tiers — cooler data stays available, just slower to retrieve. Since OneLake storage is billed separately from capacity, this can translate to meaningful savings depending on how much cold data you’re holding.

The second is OneLake item size reporting: usage reporting showing where things are stored and how large your items actually are. It’s related to the capacity metrics app but goes deeper — the capacity metrics app doesn’t offer this level of granularity. Between the two, you get both the visibility to find your storage costs and the mechanism to do something about them.

Data Engineering: materialized lake view lineage and GraphQL authorization

Extended lineage for materialized lake views (note: lake views, distinct from materialized views in KQL) is fit-and-finish work on a relatively new lakehouse feature. Previously lineage stopped at the immediate predecessor; now it traces the full path back through shortcuts, giving you the complete lineage hierarchy and dependency order. You can refresh without dependent lineage, with dependent lineage, or with the new extended lineage — which should also make refreshes more efficient.

“Authorize with User Data Functions for the API for GraphQL” is a mouthful of a title for a genuinely interesting capability. Distilled: it lets you insert custom business logic between the GraphQL API and the data retrieval. Previously you granted access and that was the boundary. Now you can write a User Data Function that has to be satisfied before data comes back — enabling row-level security patterns, privacy filtering, or any custom rule you want to enforce at the endpoint. Think of it as OneLake security’s approach applied to the GraphQL surface. In preview, and enabled per endpoint.

Data Science: AI functions go GA on GPT-5 mini

AI functions reached general availability with new models, no package dependencies, and better usage stats. The default model is now GPT-5 mini with low reasoning enabled, powering AI functions across pandas, PySpark, Data Warehouse, and Dataflows Gen2. Important housekeeping for anyone with pinned models: pipelines pinned to GPT-4.1 needed migrating before its May 30th retirement, and anything on GPT-4.1 mini needs to move to GPT-5 mini ahead of the June 15th retirement. If you’re listening to this after the fact, go check.

Two other changes worth noting: AI function chaining with PySpark was simplified around staying bound to the result schema, and AI functions in pandas no longer require the openai Python package — no more referencing it at the top of your notebooks. Small, but it removes a step.

Conversational Analytics: a new section, and a lot in it

Conversational Analytics shows up as its own section this month, pulling data agents and Copilot out from under Data Science. The split makes sense: Data Science is about programmability and the insight you get from notebooks; Conversational Analytics is about how you talk to your data.

Service principal support for Fabric Data Agents is in preview, and it fixes a real maintainability problem — agents were previously tied to an individual person’s identity, which is exactly what you don’t want in anything you intend to keep running. Foundry-based agents get the same support from the Foundry side. Data agents in Microsoft 365 Copilot reached general availability, which is a welcome milestone for a feature whose early releases took some patience to get running in Teams.

There’s also a creator agent for SQL and Event House sources — an agent that helps you set up data source connections inside your data agent. Yes, it’s an agent for creating agents, and yes, that gets meta quickly. But the use case is legitimate: the people building agents are generally not DBAs, and knowing the right, efficient, secure way to connect to a data source is exactly the kind of knowledge gap that’s worth automating. If you’re building agents and not asking “what’s the most efficient and secure way to make this connection,” start.

The preview runtime opt-in for data agents lets you put an individual agent on the preview runtime so it picks up new preview features as they land. Useful for experimentation; worth thinking hard about for production work. If you’re building for customers who need clear answers about exactly how a system behaves, an opt-in that changes what’s running underneath you is a tradeoff to go into deliberately.

Three more Conversational Analytics items round it out. A new natural language to SQL engine improves the conversion of conversational questions into SQL — incremental, but exactly the thing that used to draw a “that’s not how AI works” response and now, increasingly, is how it works. The improved data agent routing across sources gives you control over how an agent decides which source best answers a question. The Google Maps analogy fits: by default it picks a route for you, but now you can open the options and specify how you want to get from Texas to Canada — toll roads, construction avoidance, all of it. And the code interpreter tool (preview) lets an agent invoke Python for complex questions that can’t be answered with a single query against a single database, showing you the generated Python along the way. Code generation to Python isn’t new; having it generated in the context of an agent answering your question is.

That’s where the episode calls time. Data Warehouse has real substance this month, Real-Time Intelligence needs a full session of its own, and business events in Fabric is a whole topic — plus Data Factory and database apps haven’t been touched. This one may end up a three-parter.

Links

Microsoft Blog Posts

Previous Episodes

Subscribe: SoundCloud | iTunes | Spotify | TuneIn | Amazon Music


Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.

AvePoint