Every classified article, newest first. Filters combine.
Promotes SQLCon/FabCon Europe 2026 and points to where the SQL team will present sessions and roadmap items. Useful for finding talks, but it doesn’t provide technical details or platform learnings in this post.
Conference schedule/boilerplate announcement, little technical substance.
This release describes anonymous data access for Fabric Apps to enable public experiences without mandatory sign-in, gated by tenant admin approval and app opt-in. It emphasizes least-privilege permissions, field restrictions, and monitoring—key for governance and risk control.
Preview introduces anonymous access for Fabric Apps with admin/data-model controls.
The post details OneLake Security improvements for SQL analytics endpoints, including nested group support and reduced friction in shortcut-backed/hub-and-spoke scenarios. It’s directly relevant to enterprise governance correctness across identities and engines.
OneLake Security behavior changes for SQL endpoints: groups, shortcuts, service principals.
The post explains how Custom SQL Pools (preview approaching GA) provide workload isolation and governance levers for Fabric Data Warehouse under allocation-based billing. It frames the performance-vs-consumption tradeoff and how isolating business-critical vs ETL/ad-hoc workloads can prevent aggressive scaling.
Preview Custom SQL Pools add workload isolation controls impacting allocation-based consumption.
The preview enables Fabric to mirror a Google Lakehouse runtime catalog (Iceberg) so supported tables appear in OneLake for Fabric experiences without moving/duplicating data. For multi-cloud estates, this reduces custom ingestion and ongoing synchronization overhead, but raises questions about metadata consistency and supported table capabilities.
Mirrors Google Iceberg runtime catalogs into OneLake without data duplication.
The article proposes using AI to generate DAX test queries for measures by enumerating representative filter-context cases. It emphasizes that AI helps automate test case discovery, while humans must still validate expected outcomes.
Useful approach for repeatable measure testing, but AI uncertainty remains a risk.
Covers Semantic Link Labs notebook tooling that provides interactive UI for semantic model lineage exploration and Vertipaq-style analysis. This matters for faster impact assessment and troubleshooting, especially during migrations or semantic refactors.
UI tools in notebooks for lineage/Vertipaq analysis increase operational semantic model visibility.
Eventstream preview adds workspace identity-based authentication for Azure Event Hubs sources using the Fabric workspace identity plus Azure RBAC. This directly reduces shared secret management and aligns streaming setups with Entra/role-based access patterns.
Workspace identity for Eventstream Event Hubs removes shared-key credential handling.
Announces a new generally available KPI visualization for Fabric Real-Time Dashboards. It supports multiple display modes (number/bar/gauge/donut) with configurable min/max, warning/critical ranges, and reference indicators driven by KQL numeric outputs. This matters for operational monitoring where “is it healthy?” needs to be answerable from one glance.
GA KPI visual for Real-Time Dashboards; adds health ranges and status context.
Introduces a preview that combines MCP with “Agent Skills” for Fabric Data Warehouse to let agents execute SQL through a governed MCP server. The post frames the workflow benefits (draft/validate/troubleshoot/monitor) but doesn’t include concrete governance, access model, or performance/cost behavior. Interesting for experimentation, but not yet actionable for production architecture decisions from this text alone.
Preview agentic warehouse tooling via MCP; limited operational detail provided.
A deep-dive (part two) on implementing Bronze→Silver→Gold layers with Fabric Data Warehouse and the “one job per layer” principle. It describes how Bronze should be raw landing/staging with minimal transformation, and outlines implementation approaches and T-SQL patterns. Useful as architecture hygiene guidance, though it’s instructional rather than a feature/capability change.
Solid medallion layer role separation guidance with T-SQL patterns.
Explains an updated generally available billing/personalization model for Fabric Plan when used for PowerTable and Intelligence. The key change is session tier behavior: provision can be created without Planning sheets and stays at a Stakeholder tier until a Planning sheet is created/accessed, triggering an upgrade to Planner with user notification. This matters for cost governance in planning environments with fluctuating contributors.
GA billing/persona changes for PowerTable in Fabric Plan sessions.
Announces generally available customer-managed key (CMK) REST APIs for Fabric workspaces. It enables programmatic apply/rotate, inspect state, reset to Microsoft-managed keys, and tenant-wide governance—addressing portal-only scaling and audit/provisioning needs. This is directly relevant to compliance automation and encryption posture enforcement at scale.
GA CMK workspace encryption lifecycle APIs enable tenant-scale automation.
Provides a networking/connectivity decision guide for Fabric integration scenarios using Data Factory runtime components (e.g., Dataflow Gen2, Pipelines, Copy). It focuses on choosing between VNet gateway, on-prem gateway, or direct cloud connections based on data source location and private network boundary requirements. Useful for reducing integration surprises, but it doesn’t go into Fabric-specific CU/perf implications in the excerpt.
Connectivity guidance for Fabric data integration workloads and gateways.
Promotes FabCon + SQLCon 2027 and provides guidance on selecting a submission track for session proposals. It’s useful for speakers, but contains no technical changes, architecture details, or governance/cost implications for Fabric users. Likely not actionable for platform engineering decisions.
Call-for-sessions track selection guidance; no Fabric technical impact.
Announces a preview where Fabric data agent visual outputs use Fabric Visuals instead of a standalone rendering approach. It claims improved fidelity/legibility (legends, tooltips, axis scaling) and more consistent chart rendering across Fabric. For most teams this is a UX/consistency change, but it’s preview and the snippet doesn’t address performance, governance, or data-access behavior.
Preview upgrade: data agent charts now render with Fabric Visuals.
This update brings Eventstreams observability into Fabric Workspace Monitoring with KQL-based metrics and error tables. It adds a per-eventstream toggle so you can choose which streams emit monitoring data, reducing unwanted monitoring overhead.
Eventstreams monitoring in Workspace Monitoring gains per-eventstream opt-in controls.
The article announces generally available data source routing in Fabric data agents. The key implication for platform operators is more reliable/controllable destination selection behavior, useful when coordinating migrations and governance across environments.
Data agent routing GA suggests deterministic target selection for connectors/destinations.
The post describes GPU-powered Query Acceleration in Fabric Data Warehouse, enabled via a toggle in preview. It focuses on how the engine identifies eligible query plan operators for GPU offload, which matters for latency/performance expectations and operational rollout.
GPU Query Acceleration preview: offloads eligible operators; impacts performance planning and cost.
This is a part of a Fabric/hosting business events educational series, moving from concepts to implementation patterns. For an architect, it’s likely helpful for event design, though this specific post excerpt is mainly framing rather than concrete operational details.
Business Events series—useful patterns, but lacks platform internals or costs here.
The third post in the series focuses on designing a business event schema that downstream consumers can act on. The excerpt signals patterns will follow, but the technical specifics are not visible here.
Business event schema design for consumer action, but details not included in excerpt.
This post introduces a series comparing Business Events, Fabric Events, and Azure Events for event-driven solutions. As presented, it reads as a foundational overview that will matter later once concrete schema/routing patterns are covered.
Event architecture pillar overview likely useful but no implementation specifics shown yet.
Provides a fundamentals overview of event-driven architecture in Fabric using Real-Time Hub and Business Events. It’s positioned as learning material and doesn’t provide actionable architectural or operational guidance for production builds.
Intro-level event-driven education; useful awareness but lacks implementation specifics.
Documents Fabric Data Agent changes: moving integrations from Assistants API to Responses API with a migration deadline. Provides a migration helper (RANCH) that converts notebooks via pattern-based code scanning. This is actionable for platform teams managing API/SDK changes and CI/CD readiness.
Migration off Assistant API to Responses API with notebook-conversion helper.
Explains a workaround using the Paginated Report visual to display Detail Rows Expression results, including how to wire parameters and datasets using DAX EVALUATE DETAILROWS().. Mostly relevant for Power BI report authors; it’s less central to Fabric architecture decisions.
Paginated drillthrough workaround for Detail Rows Expressions, mostly Power BI UX behavior.
The post promotes new Fabric “skills” that help AI coding agents create and manage SQL database components. From a platform perspective, the usefulness depends on how much it covers governance, deployment, and performance tradeoffs—none are evident in the excerpt.
Preview “SQL database skills” guidance is likely marketing-forward without technical specifics.
The update introduces Fabric Lakehouse support in the dbt job configuration experience (preview). It enables targeting Fabric Lakehouse directly for model/test workflows, supporting Lakehouse-first architectures and simplifying integration into analytics engineering pipelines.
dbt can run directly against Fabric Lakehouse; improves Lakehouse-first transformation workflows.
The post announces GA for Capacity Overview Events in the Real-Time Hub, aimed at monitoring capacity conditions and triggering alerts/actions near real-time. For ops and platform governance, this enables event-driven automation around surge protection/throttling responses.
GA Capacity Overview Events provide near real-time capacity monitoring and automation hooks.
A short GA announcement stating that Fabric Runtime 2.0 is the execution foundation for Spark-based experiences. However, it provides no actionable migration, performance, compatibility, or cost details in the excerpt.
Runtime 2.0 GA announcement, but lacks technical deltas or operational impact details.
Announces enterprise auditing improvements via identity-based predicate filtering for SQL audit logs. For credible adoption, you’d still need the exact configuration model and any filtering limitations.
GA for predicate filtering in SQL audit logs is governance-relevant but needs implementation specifics.
Reports the July 2026 on-premises data gateway release (v3000.326) and notes alignment with the July 2026 Power BI Desktop query execution logic. This matters for regulated environments where behavior changes and diagnostics/auth updates must be controlled.
Gateway version 3000.326 aligns refresh execution logic with July 2026 Power BI Desktop runtime.
GA note for SQL Server 2025 enabling database-side outbound AI calls under existing trust/control models. The key value is the security framing for preventing secret/data exfiltration via centralized enforcement.
Outbound AI connectivity in SQL Server 2025 adds a governed control plane.
Provides an approach to explain warehouse-level CU consumption by correlating Capacity Metrics timepoints with Query Insights data. The emphasis on a query-level weighted attribution method is directly actionable for capacity attribution and post-mortems.
Combines Capacity Metrics and Query Insights for practical query-level CU attribution.
Discusses using AI to generate DAX (e.g., New Customer pattern) and then refactoring it into better, reusable UDF/measure code. Useful for personal DAX hygiene, but it doesn’t address Fabric Direct Lake/semantic model performance or capacity implications.
Mostly about AI-generated DAX refactoring; little Fabric/scale guidance.
Promotes an AI-assisted workflow to build/refine Data Agents using guided configuration and testing. As presented, it’s mostly feature marketing without the operational guardrails (privacy, governance, evaluation) this reader needs.
AI build-agent preview for Data Agent configuration; excerpt lacks governance, cost, or accuracy constraints.
This covers Delegated OneLake Shortcuts (preview) to address pass-through limitations like permission scaling and cross-tenant reuse. If you’re designing governed, reusable datasets, the delegated model is a key architectural decision point.
Delegated OneLake shortcuts aim to scale secure access without per-user source provisioning.
Explains how to restore alternating row colors in Power BI Matrix visuals when Fluent 2 defaults remove them. This is a report-level UX workaround rather than an architecture or performance topic.
UI styling tip for Matrix alternating rows, not platform-relevant.
Shows how to drill to a different fact table using Detail Rows Expressions, particularly when combining DirectQuery/Import and hidden detail tables. It’s a useful modeling/reporting technique but not a Fabric-operational or Direct Lake internals deep-dive.
Detail Rows drill to an alternative fact table—interesting, but not a Fabric internals topic.
Fabric will roll out Item Recovery by default to tenants without an explicit setting on Aug 16, 2026, with a 3-day default window. Admins can still disable or adjust retention (3–90 days), and explicit existing settings are preserved.
Default retention change affects recovery posture and tenant administration.
A preview opt-in adds a modern evaluation engine execution path for supported Mashup evaluations when using VNet data gateways. It targets refresh/performance efficiency without changing the gateway connectivity model, so you must test representative workloads before broader adoption.
Preview execution path for Mashup evaluations via VNet gateways; needs workload benchmarking.
Scheduled User Data Functions (preview) let you attach a recurring schedule to user-defined business logic executed close to data. This reduces reliance on external orchestration while leveraging Fabric job scheduler monitoring/troubleshooting.
Scheduled User Data Functions embed recurring logic into workspace jobs.
A part of a medallion-architecture series that reframes the core decision from Lakehouse-vs-Warehouse to how much Spark you actually need. It explains how to map Bronze/Silver/Gold layers onto Fabric Data Warehouse and/or Lakehouse with tradeoffs for security and maintenance.
Guidance on selecting medallion mappings to Fabric DW vs Lakehouse based on Spark needs.
Introduces mirrored Azure Monitor (from Log Analytics tables) and mirrored AWS Glue catalog access (preview) to extend OneLake reach. It matters for multi-cloud/telemetry integration architecture by reducing custom pipelines, but as a preview it warrants evaluation of governance, lineage, and operational behavior.
Preview OneLake mirroring for Azure Monitor and AWS Glue catalog metadata/data reflections.
Fabric SQL database can (in preview) stream inserts/updates/deletes to Fabric Eventstream or Azure Event Hubs for near-real-time pipelines. This is relevant for operational-to-analytics designs, but an excerpt without constraints/limits limits practical assessment.
Preview for streaming SQL database changes into Eventstream/Event Hubs.
This post positions Eventhouse as a unified engine to ingest, store, and analyze high-volume event data near real time. The excerpt is conceptual and lacks the concrete architecture, performance, and governance considerations needed to decide applicability.
Eventhouse marketing-style positioning; needs deeper technical evaluation for fit/cost.
Demonstrates using M365 Copilot in Excel to analyze a Power BI semantic model and generate worksheets for ABC analysis. The excerpt highlights that Copilot pulls raw data and uses Excel logic rather than binding to a DAX UDF, which informs expectations more than architecture.
Copilot-in-Excel behavior and DAX query generation is noted, but not governed/costed.
A monthly spotlight linking to MVP/super-user work across Fabric. For an architect, it’s mainly discovery/curation rather than actionable implementation detail.
Influencer roundup; no technical Fabric or operational substance.
This introduces structured runtime release channels so admins can opt into early access and validate Spark runtime upgrades in staging. For production operations, this is directly relevant to upgrade risk management and regression planning.
Release channels let you test runtime changes before default rollout, reducing surprises.
A monthly Fabric feature summary mentions a fabric-cicd tool update (bulk publish mode in preview). However, the excerpt contains limited technical specifics and is mixed with event/certification promotions.
Feature-summary post is useful for radar, but mostly promotional content is included.
Announces retirement of the Copilot in Power BI integration with Fabric data agents due to underlying OpenAI Assistant API retirement. It matters for governance and user experience planning: after Aug 26, Copilot will no longer route Q&A through Fabric data agents, though data agents still work in other supported entry points.
Copilot-in-PowerBI to Fabric data agents integration is retired Aug 26, 2026.
A marketing-style post about Forrester Wave leadership for data lakehouses, referencing Fabric/OneLake. It doesn’t add operational details (capacity, semantic model behavior, governance settings) needed for architecture decisions.
Forrester recognition; no Fabric internals, costs, or implementation guidance.
Explains Workspace Outbound Access Protection (OAP) as a workspace-level outbound security perimeter for Eventstream destinations. This is directly relevant to preventing misrouting of sensitive streaming data and to designing secured workspace boundaries and approval flows.
Workspace Outbound Access Protection constrains where Eventstream data can go.
Covers code samples and patterns for event-driven apps using Business Events and User Data Functions. Likely useful for implementation direction, but the provided text doesn’t show specific APIs, limits, or operational costs.
Generic architecture/pattern post; limited concrete Fabric implementation detail in excerpt.
Promotes Fabric Real-Time Dashboard as a fast live view over streaming data. For this reader it’s mostly positioning without details on latency, scaling, licensing, or semantic/model implications.
Real-Time Dashboard pitch; excerpt lacks technical constraints/behavior.
Announces Fabric Embed preview focused on embedding Real-Time Dashboards in JS/TS using an SDK and delegated access tokens. It’s relevant for application embedding governance and token-based access patterns, but the excerpt doesn’t include limitations/permissions model specifics.
Fabric Embed preview supports embedding Real-Time Dashboards with delegated access tokens.
Fabric adds GA job concurrency and queue monitoring with a capacity-level view. This helps distinguish workspace limits vs capacity saturation vs cross-workspace contention during Spark queuing.
Adds capacity-level job queue/concurrency visibility to diagnose Spark throttling.
The post frames using Azure Monitor data inside Fabric to connect system health signals to business impact. For this reader, the value depends on concrete ingestion, mapping, and alert-to-action mechanics, which aren’t provided here.
Azure Monitor-to-Fabric preview is plausible but lacks operational implementation detail.
Customer-managed key encryption now covers Spark job processing, not just data at rest in storage. This is meaningful for regulated workloads where encryption scope and key control during execution matter.
Extends customer-managed keys to Spark compute processing layer.
Planning in Microsoft Fabric IQ is announced as GA with claims about moving from spreadsheets to integrated planning. The excerpt doesn’t provide implementation details or constraints needed for production architecture decisions.
Planning in Fabric IQ GA is largely marketing-focused with no architecture/cost/governance specifics.
Describes enhancements for integrating Fabric data agents into Microsoft Foundry agents using Model Context Protocol (MCP). Focus is on easier discovery/integration and better operational visibility once deployed, reducing friction for tool-grounded enterprise data access.
Fabric data agents integration via MCP plus monitoring/visibility improvements for production trust.
Fabric introduces Native Execution Engine performance optimizations for Spark, largely on by default. For a platform practitioner, the key will be which query patterns improve and how regressions are mitigated.
Native Execution Engine optimizations promise faster Spark queries with low user effort.
The post covers summer updates: OneLake security applying to Eventhouse and Graph Database, a simplified CLS experience, and faster role review in the OneLake catalog secure tab. It matters operationally for maintaining security configurations at scale.
OneLake Security expands to more engines and improves CLS UX and catalog performance.
Announces that Fabric Spark’s Native Execution Engine now uses a purpose-built SIMD CSV reader (Velox) instead of falling back to the default Spark CSV reader. This should reduce row-to-columnar conversion overhead and improve CSV read throughput without code changes, with benchmark-dependent gains.
Tier A performance/cost change: Native CSV reader in Spark, benchmarks and no-code impact.
Walks through how visual calculations can help or hurt performance, using an example involving distinct counts and YOY growth. It’s actionable for report authors, but it stays within Power BI/DAX basics rather than Fabric-scale Direct Lake semantics.
DAX performance theory for visual calculations; generic to this reader.
Warns that OpenAI Assistants API (used by Fabric data agent orchestration layer) is scheduled for shutdown on Aug 26, 2026. Fabric recommends migrating programmatic integrations to the data agent MCP endpoint rather than building against OpenAI Responses API.
Direct breaking change timeline: Assistants API retirement; migration path to Fabric data-agent MCP endpoint.
Preview GA-style announcement for VNET Data Gateway autoscaling based on workload demand. It highlights cost/performance trade-offs using min/max node limits, but preview scope/limitations aren’t provided in the excerpt.
Preview autoscaling for VNET gateway targets reliability/cost during spikes.
Argues that the new M365 Copilot + Power BI approach generates/runs DAX queries, making model preparation still valuable. The post frames two risks—correct-but-nonoptimal performance/CU and inconsistent end-user instructions—and positions DAX UDFs as mitigations.
Discusses the Copilot direction shift and why DAX UDFs still matter for accuracy/cost.
Uses an e-commerce intent/revenue narrative to describe an event-driven streaming pipeline with Eventstreams, Spark, and AI Functions. For this reader, it reads more like a use-case story than an engineering blueprint (no concrete tuning/monitoring patterns).
Marketing-style streaming/AI scenario; limited technical configuration detail.
Announces Generally Available resource instance rules to simplify OneLake network security for trusted Azure service identities. It targets operational pain from IP allowlists/private networking by allowing service-to-service access based on verifiable Azure resource identities, layered with Private Link and identity permissions.
GA network-security mechanism for OneLake: resource instance rules for service-to-service access.
Shares Forrester’s Leader recognition for multimodel data platforms and ties it to Fabric’s unified governance narrative. This is not actionable for architecture decisions and contains no implementation-level details.
Forrester recognition press content; no technical or cost/behavior details.
Announces Lakehouse Query Explorer (GA), an embedded Spark SQL query experience in the Lakehouse explorer. Intended for fast validation/exploration before committing to notebooks, views, semantic models, or downstream pipelines; helpful for workflow efficiency but not deeply architectural.
Useful tooling for exploration: Lakehouse Query Explorer for Spark SQL inside explorer.
A forward-looking post about conversational analytics across Fabric and Microsoft endpoints. Likely useful for roadmap context, but it reads as marketing-level without operational details for Fabric architects.
Conversational analytics positioning; lacks internals, costs, or governance specifics.
Describes Fabric mirroring of Snowflake-managed Iceberg tables into OneLake without data duplication. It explains how Iceberg metadata is replicated and how virtualization as Delta enables multiple Fabric engines to read natively.
Mirroring Iceberg via metadata shortcuts reduces duplication and sync pain.
Explains Fabric Planning (Preview) billing logic and how it differs from consumption/seat pricing. It emphasizes predictable, cycle-based workload economics and references using Capacity metrics app for tracking planning usage.
Preview planning billing model adds economics and capacity-metrics visibility.
Tests using Fabric Operations Agents with Workspace Monitoring to alert on DAX query errors from Power BI semantic models. The value is the concrete instruction pattern (what to alert, what metadata to include) and the tie-in to Workspace Monitoring’s KQL tables.
Operational Agent patterns for detecting DAX errors via Workspace Monitoring KQL.
GA announcement for OneLake storage tiers and lifecycle management. It focuses on moving aged data from hot to cool/cold while keeping it online and discusses using reporting/logs to find tiering targets.
Lifecycle tiering is a direct lever for long-term OneLake cost control.
GA feature for OneLake item-size reporting per workspace. It enables admins to identify large/problem/system/soft-deleted items and refresh usage to drive lifecycle policy decisions.
Storage report gives actionable item-size visibility for cost and cleanup.
Explains using User Data Functions to securely call Fabric REST APIs with centralized auth/authorization. The post’s practical value is credential minimization via service principals and Key Vault, creating an auditable orchestration layer.
User Data Functions act as a governed Fabric REST API gateway pattern.
A short update about Fabric Data Factory improvements like smarter authoring and observability. It doesn’t include enough technical detail to evaluate operational impact or costs for production architectures.
Claims smarter pipelines/monitoring but provides no concrete config or behavior.
Describes a row-to-intelligent-action pattern for game-day operations using CDC, DeltaFlow (preview), and Spark Structured Streaming. Useful as an architectural reference, but it reads more like a showcase than a capacity/governance or performance deep-dive.
Concept-heavy Eventstreams+Spark AI flow; preview patterns with limited operational detail.
Updates Dataverse Fabric Link to let admins choose which tables are linked, improving control, security, and reducing synchronization latency. For Fabric architects, this directly affects workspace complexity, downstream model scope, and storage/cost behavior.
Dataverse Fabric Link table selection and security/latency controls matter for cost and governance.
Shows how to drive per-hierarchy-level formatting using ISINSCOPE (model) vs ISATLEVEL (visual calculation). It’s a solid DAX pattern, but it’s primarily presentation logic rather than a scalable semantic/capacity concern.
ISINSCOPE/ISATLEVEL hierarchy formatting; useful but not Fabric internals.
Provides OneLake architectural guidance mapping business initiatives to repeatable enterprise patterns (unified access, medallion, etc.). It’s actionable blueprinting territory—relevant for designing governed, AI-ready lakehouse foundations.
OneLake architectural blueprint with enterprise patterns; strong guidance for AI-ready estates.
Chris Webb discusses Direct Lake benefits (mainly near-instant refresh via framing) but cautions that overall cost depends on how data gets into OneLake and whether gold tables are created/optimized. It frames Direct Lake as often good, not universally best—especially versus Import or composite patterns.
Compares Direct Lake refresh/frame cost vs Import and gold-layer tradeoffs.
Announces a new Oracle CDC source connector for Fabric Eventstreams (preview) capturing insert/update/delete events with before/after values. This is a direct enabler for event-driven architectures without nightly snapshot ETL.
Oracle CDC connector to Eventstreams enables true row-level near-real-time ingestion.
Summarizes 2026 Q2 capabilities for Fabric Eventstreams across connectors and stream processing. It’s timely for implementation planning—especially GA status, authentication, and mTLS/networking considerations.
Q2 Eventstreams release highlights GA connectors, SQL stream processing, and security/transport upgrades.
Walks through streaming operational changes into Fabric using mirrored databases, Delta Change Data Feed, and a Mirrored Database Change Feeds connector (preview) into Eventstreams. Good reference for how to compose multiple features into a production-like pattern.
Concrete row-to-action scenario combining mirroring, Delta CDF, and Eventstreams routing.
Updates SQLBI’s internal generative AI guidelines, covering how they use AI in production (subtitles, DAX analysis/testing) with human review. Relevant for operational governance of AI-assisted development, but not about Fabric platform mechanics.
AI usage guidelines with production workflow details; not Fabric-specific internals.
Shares a technical, measurement-focused test of GPU-accelerated query execution for Fabric Data Warehouse using OneLake parquet data. While explicitly non-official and limited-availability, it’s the kind of evidence you can use to estimate impact and constraints.
GPU query execution in DW with methodology and region/capacity caveats—worth evaluating.
A short entry implying Rayfin AMA with Q&A, but the provided text has no technical substance to triage. Insufficient detail to judge relevance for Fabric architecture or operational cost.
AMA without content details; likely marketing/community wrapper.
The post explains using Purview sensitivity labels on Fabric/Power BI items to guide AI agents on which data is relevant, alongside enforcing protection policies. It’s a governance-centric pattern; the practical operational details and limits aren’t covered in the provided text.
Sensitivity labels are positioned as signals for AI agent data selection and alignment.
This post explains the Power BI Service error where a semantic model’s database is evicted due to CPU load, canceling in-flight queries/refreshes. It links the symptom to node resource pressure and suggests scale-out plus tuning to prevent recurring issues.
Explains CPU-load eviction behavior and mitigation options like scale-out.
The article previews Workspace Outbound Access Protection for RTI scenarios, intended to reduce data exfiltration risk while keeping ingestion/analytics/automation functional. Useful for security architects, but the supported item matrix and enforcement behavior aren’t included in the excerpt.
OAP preview adds workspace-level exfiltration controls for supported real-time intelligence workflows.
It targets securing zero-copy distribution patterns using OneLake security and shortcuts, likely focusing on how permissions propagate without copying. That matters for scale and governance, but the excerpt provides no concrete mechanics or constraints.
Zero-copy distribution security via OneLake security and shortcuts is operationally critical.
The post lists connector updates for Fabric Eventstream, including generally available mTLS/custom CA and private network support, plus preview capabilities like workspace identity support. It’s relevant to secure RTI ingestion design, though sizing/performance and exact configuration details aren’t present.
Eventstream connector updates expand security and coverage for private networks and enterprise sources.
This announces the Fabric data agent API moving to public, with management-plane lifecycle operations from outside Fabric (including SDK use). For platform teams, this unlocks repeatable promotion and automation, but you’ll still need to validate API capabilities and governance implications.
Public Fabric data agent API enables lifecycle management via CI/CD and external tooling.
This introduces generally available Item Recovery, allowing recovery of deleted items across supported workloads with tenant-wide recovery policies. Operationally, this changes incident response and governance defaults for deletion events.
Item Recovery GA adds restore and policy controls via recycle bin and REST API.
Introduces AI-assisted command-line skills to migrate Synapse Spark pools, lake databases, notebooks, and Spark job definitions into Fabric. Also provides optional migration for Data Factory pipeline orchestration, including dependency resolution and blocker detection with an idempotent flow and migration reports.
Preview CLI migration skills with dependency-aware, idempotent Synapse→Fabric moves.
Explains how returning REMOVEFILTERS from a DAX UDF can remove unwanted calendar filters and fix a failing time-intelligence measure. It’s a strong DAX correctness/performance-related pattern, though it remains within Power BI semantics.
UDF behavior and REMOVEFILTERS macro-expansion edge case—practical DAX correctness.
Adds Outbound Access Protection to restrict which workspaces can consume Azure/Fabric events. Matters for hardening Real-Time Events integrations and preventing accidental/unauthorized event access across tenant-adjacent boundaries.
New outbound access controls for cross-workspace event consumption security.
The author revisits storage mode guidance, arguing DirectQuery can be the better choice when datasets are too large for comfortable Import/Direct Lake scenarios. It’s a stance-changing, experience-driven perspective, but without enough specifics in the excerpt to validate exact decision criteria.
Reassesses DirectQuery, arguing it can fit larger volumes under conditions.
Details Efficient Scaledown (Preview) for Spark by decoupling shuffle data from executor lifetime. The key value is more resilient scale-down for shuffle-heavy jobs, reducing retries and cost without query/pipeline changes.
Efficient Scaledown tackles shuffle pinning and scale-down failure modes.
Focuses on making data “AI-ready” via Fabric’s built-in data protection and Purview integration. It’s more of a security framing than an implementation guide, but it’s relevant to access-controlled AI usage patterns and governance expectations.
Positions Purview classification/control/observability as the basis for safe AI access.
Describes a Bulk Copy API client-side ingestion path for Fabric Data Warehouse, intended to bypass intermediate staging for app-produced data. Useful for throughput tuning, but you’ll still need to validate constraints, batching strategy, and failure/ordering semantics for correctness.
BCP API claims 5–10x ingestion throughput versus INSERT-only patterns.
Announces the June 2026 on-premises data gateway release (v3000.322) with Windows Web Account Manager authentication support, an Apache Log4j security update, and consent-driven diagnostics uploads. Operationally important for security posture, troubleshooting, and governance reporting for Fabric connectivity.
Gateway v3000.322 adds WAM auth, Log4j security fix, and consent diagnostics.
Highlights Fabric Influencers (MVPs/Super Users) for June 2026. For a platform practitioner it’s mostly networking/community visibility rather than actionable technical or governance detail.
Monthly spotlight post; minimal architecture or operational substance.
Introduces a GA stored procedure (sp_get_table_health_metric) on the Fabric SQL analytics endpoint to assess Lakehouse table storage/structural health before running maintenance. This reduces reactive firefighting and wasted OPTIMIZE cycles by turning health diagnosis back into a T-SQL workflow.
New T-SQL sp_get_table_health_metric for pre-maintenance Parquet health checks.
Provides a curated “what’s new” roundup across SQL Server, Azure SQL, and SQL database in Fabric through mid-2026, grouped by service and marked GA/Preview. Helpful for staying current, but it’s not deep operational guidance for Fabric platform design decisions.
Quarterly SQL feature compilation; useful but mostly index/listing.
A brief GA announcement for using Fabric Data Factory patterns in multi-cloud data integration. It doesn’t include concrete patterns, costs, or operational considerations in the provided text.
GA headline with no architectural detail provided.
Describes how Fabric’s Native Execution Engine improves performance for Python/Scala UDFs and complex nested types. It highlights removing JVM↔Python roundtrips and avoiding fallback to slower execution, with reported 2–5x benchmarks.
Native Execution Engine targets UDF serialization and complex-type slow paths.
Announces GA of invoking Copy jobs directly from Fabric Activator. The operational impact is eliminating schedule-based empty runs by moving only on events/changes, simplifying event-driven data movement.
Activator can trigger Copy jobs event-driven without extra pipeline orchestration.
A brief review of “Extreme DAX” 2nd edition highlights that it goes beyond basics into advanced DAX topics like Auto-Exist. For a Fabric/Power BI practitioner, it’s mainly reading recommendation rather than actionable platform guidance.
Book review with advanced DAX topics but not Fabric architecture guidance.
Calls out new preview T-SQL string functions and approximate string matching operators in Fabric Data Warehouse. Value is practical developer productivity, but the text lacks performance/cost or migration implications.
Preview string functions/operators are useful but not architecture-critical.
A World Cup weather monitoring narrative using Eventstream and Eventhouse AI Skills. It’s largely marketing/demo oriented in the provided text and doesn’t cover operational architecture or performance considerations.
Demo-centric Eventstream+AI story; no technical or cost details.
Explains Microsoft’s plan to bring connectors in-house to improve connector supply-chain security and clarify lifecycle support. This matters for enterprise governance because it changes how connectivity is secured, shipped, and maintained over time.
Connector supply-chain in-house shift affects lifecycle, security, and support.
Announces a new ServiceNow connector to query data stored in OneLake without copying (preview). For a Fabric operator, the value hinges on connector semantics, supported query patterns, and how governance/permissions map into workflow use cases.
Zero-copy OneLake connector for ServiceNow; review limits, governance, and end-to-end performance.
Preview note for an AI skill that converts Spark troubleshooting into a single natural-language command. As presented, it doesn’t cover accuracy, cost/compute impact, supported error classes, or how it integrates with existing debugging workflows.
AI-based Spark diagnostics is mostly capability marketing; lacks operational details or failure modes.
Reports a Fabric Spark History Server performance improvement using snapshot-based, incremental loading. Also mentions removing restrictions around spark.eventLog compression/rolling, which can affect compatibility and operational tuning for large workloads.
Snapshot-based Spark History Server loading targets concrete pain at 10GB+ logs.
Shows how to add optional parameters with default expressions in DAX user-defined functions. The main value is syntactic/function design clarity rather than engine-level performance or governance considerations.
DAX UDF optional parameters are useful but not Fabric-architecture critical.
Explores a newer Dataflows Gen2 option to disable V-Order for staged parquet/Delta storage, trading write-time optimization for faster staging and (usually) better end-to-end refresh. Includes concrete timing from staging and downstream group-by, plus a noted constraint around Fast Copy.
Quantifies Dataflows Gen2 V-Order impact; actionable tuning for Direct Lake refreshes.
Evaluates whether more parallelism always helps for Fabric Dataflows Gen2 using Partitioned Compute and Excel-from-SharePoint inputs. The results show a non-linear optimum (best around moderate concurrency) and highlight external bottlenecks like file-source behavior and throttling.
Tests partitioned compute concurrency with many files; reports concrete refresh-duration results.
Compares ALL, ALLSELECTED, ALLEXCEPT, and REMOVEFILTERS with guidance on when to use each. It targets correct filter-context manipulation, not Fabric-specific internals or scaling concerns.
Classic filter-context functions comparison; strong DAX relevance, low platform scope.
Uses a deliberate “delay per row” experiment to show that Partitioned Compute can evaluate row-level work concurrently, and that setting concurrency to 1 forces sequential execution. Clear evidence with before/after refresh timings and query-level breakdown.
Demonstrates how Partitioned Compute concurrency controls evaluation within a single query.
Builds a controlled test where multiple queries each take ~1 minute and demonstrates variable concurrency behavior during refresh. It explains how to cap “limit number of concurrent evaluations” and ties observed durations to parallelism limits.
Series starter with controlled multi-query concurrency effects on Dataflow Gen2 refresh.
Introduces user-aware calculated columns using the Expression Context property to evaluate at query time based on the user. It emphasizes non-materialization behavior (virtual calculated columns), with implications for localization/security and Direct Lake over OneLake.
User-context calculated columns impact Direct Lake materialization and security patterns.
Explains the “You’ve exceeded the capacity limit for dataset refreshes” error in Power BI/Fabric Premium by focusing on concurrent semantic model refreshes rather than current CU usage. Includes an investigation approach on a small F2 capacity to reveal how the limit is applied and how CU consumption can spike despite smoothing.
Breaks down the refresh-parallelism limit behind the capacity-limit dataset refresh error.
Explains the “maximum allowable memory allocation” refresh/render error and why it can be transient. Focuses on Service-side node placement and contention with other semantic model refresh/query workloads.
Direct guidance on rare Power BI memory allocation failures and node contention behavior.
Addresses the misconception that slicers can filter measures directly. It clarifies how filters always apply to columns and how to model requirements using appropriate granularity/context.
Explains a common modeling/UI misconception; not an architectural lever.
Shows how to publish a semantic model that automatically binds to an external data source using TMDL binding hints. Eliminates manual connection-ID steps via Shareable Cloud Connections.
Covers binding hints for auto-connecting published models to shareable cloud connections.
Demonstrates using FabricAI.Prompt() to generate table-shaped CSV text and convert it into rows with CSV.Document. Useful for test-data generation patterns, not production-quality governance of AI output.
FabricAI.Prompt() sample-data generation via CSV parsing in Dataflows Gen2.
Documents parameter types for DAX UDFs, especially reference types like MEASUREREF/COLUMNREF/TABLEREF/CALENDARREF. It improves authoring correctness and IntelliSense but doesn’t cover platform-level performance or deployment.
Advanced DAX UDF type system details; useful for correctness but niche.
Details how Power BI semantic model refresh warnings can appear for previously-ignored calculation issues. Uses concrete examples of calculated tables/columns/measures referencing missing tables/columns.
Refresh warnings since March 2026: errors are now surfaced instead of silently ignored.
Demonstrates a RAG notebook in Fabric using the Harrier multilingual embedding model, including options sized for Fabric execution. It claims strong retrieval metrics, discusses loading the model in a lakehouse, and includes an operational notebook pattern. Not purely architectural, but it’s grounded in performance trade-offs relevant to platform cost control.
Practical RAG approach with Harrier embeddings; notes latency and CU implications.
Argues Power BI cannot generally “just work” with third-party semantic/metric stores due to technical integration constraints. Mostly strategic context for expectations and vendor evaluation rather than actionable architecture.
Opinionated stance on compatibility limits with third-party semantic models.
Demonstrates using measures/visual calculations to highlight an entire row based on the maximum value in the last column of a visual. This is a practical DAX pattern, but it doesn’t meaningfully affect Fabric architecture decisions.
Visual-calculation row highlighting technique; mostly presentation-level.
Announces new SQLBI+ material about navigating the lattice of visual calculations in DAX. It’s useful for learning, but the post itself is promotional and doesn’t provide concrete architectural or performance guidance.
Updates/announcement for SQLBI+ content without new technical internals.
Revisits a Direct Lake pattern for creating multiple copies of the same dimension with fewer/no underlying data duplication. Provides a TMDL View editing workaround to avoid prior errors.
Workaround for role-playing dimensions in Direct Lake without duplicating underlying Delta data.
Demonstrates calling the Power BI remote MCP server from a Fabric notebook to fetch a semantic model’s Prep for AI configuration (schema, relationships, custom instructions, verified answers). For model builders, this is a practical automation hook to keep AI configuration in sync without manual exports.
Shows MCP-based retrieval of semantic prep-for-AI configuration for automated grounding.
Announces a third edition “unplugged” video and positions it as starting from near-zero DAX knowledge. It emphasizes new DAX modules (UDFs, calendar-based time intelligence) but contains no operational/architectural guidance for Fabric builds.
DAX course promotion; no Fabric/semantic or cost/performance details.
Covers generating Excel files from Dataflows Gen2 with control over formatting, positioning it as lightweight reporting/ETL output. Useful capability overview with example M usage, but less about Direct Lake/capacity-level behavior.
Shows Fabric Dataflows Gen2 exporting structured Excel outputs using Power Query transforms.
Explains how DAX user-defined functions differ from calculation groups and when each should be used in a semantic model. Highlights visibility (report-user facing vs developer-internal) and supports cleaner reuse strategies in Fabric/Tabular.
Clear UDF vs calculation groups responsibilities for semantic-model design.
Promotes the third edition Mastering DAX video course and lists new DAX language features covered. While it mentions UDFs and visual calculations, it doesn’t provide concrete implementation or scaling guidance for production semantic models.
Another course availability post; mostly marketing with minimal technical depth.
Covers updated Fabric Notebook Copilot capabilities, including interacting without a session and cross-referencing other notebooks in the workspace. This matters for productivity and standardization, but the post is mostly capability narrative rather than measurable operational impact.
Notebook Copilot cross-references can speed authoring, but CU/governance specifics are light.
Evaluates whether staging improves or degrades performance for a large CSV source with folding-sensitive transformations. Emphasizes how to detect folding on staged data and discusses outcomes from a 6GB/17M-row case.
Practical test of query folding vs staging impacts in Dataflows Gen2.
Tests Fabric Dataflow Gen2 M performance under Partitioned Compute by applying an artificial delay per-row function. Useful for deciding whether parallelization actually reduces runtime for your query shapes, not just believing the feature pitch.
Empirical tests on Dataflow Partitioned Compute show when it helps or hurts.
Shows how to convert the like-for-like comparison pattern into generic, reusable model-independent functions using DAX UDFs. It’s directly relevant to reducing semantic-model complexity and reuse across many datasets.
UDF-based refactoring of a DAX pattern into model-independent functions.
Explains how Fabric Dataflow “Enable only in previews” steps behave during authoring vs refresh, including an example where results differ. Important to prevent subtle logic bugs where preview-only transforms unintentionally diverge from production refresh outcomes.
Preview-only steps behavior is verified with edge cases and UI toggles.
Updates SQLBI+ content around visual calculations, focusing on internal concepts (visual shape/context) for experienced DAX developers. Useful for understanding what should/shouldn’t live in centralized semantic models versus report-level formatting.
Visual calculations reference material with troubleshooting-oriented framing.
Promotes Business Process Solutions as a Microsoft-developed workload to bootstrap Fabric reporting for SAP/Salesforce. As an operator, you’ll still need to evaluate cost, governance fit, and whether generated assets match your lakehouse/semantic-model standards.
Overview of a prebuilt SAP/Salesforce solution, but not an architecture teardown.
Describes how to debug DAX variables by converting intermediate table variables to JSON/CSV for inspection. This is a concrete technique for diagnosing measure logic during semantic model development.
Practical debugging technique using TOJSON/TOCSV for table variables.
Uses a DirectQuery semantic model example to show how Power BI can run multiple SQL queries in parallel, but still serializes behind a first query dependency. Concrete tuning implications: measure definitions and fusion/SQL shape can change dependency chains and total latency.
DirectQuery parallelism limits are explored via DAX Studio server timings.
Demonstrates using Power BI Performance Analyzer to measure overall report page load and interactions, including non-DAX contributors like images/geocoding. Helps avoid false positives where individual query tuning doesn’t translate into real UX improvements.
Shows how to measure full page load time, not just individual DAX.
Explains how DATEADD parameters control granularity shifts in the newer calendar-based time intelligence. Helps avoid incorrect assumptions in time intelligence implementations and clarifies scenarios where custom parameterization is required.
Calendar-based time intelligence DATEADD parameter semantics and edge scenarios.
Reviews two DAX/Power BI visual-calculation books and discusses what’s new in the DAX third edition. For this reader, it’s mostly a signal to check content later, not actionable platform guidance.
Book announcements; value depends on whether it adds new operational guidance.
States that Excel PivotTables connected to Power BI semantic models now generate MDX that avoids returning unnecessary subtotal/grand total data. This directly affects query cost and latency for mixed subtotal settings—relevant when you care about end-user responsiveness and backend load.
Reports a concrete Excel PivotTable MDX optimization for Power BI semantic models.
Shows techniques to consolidate multiple transaction attributes into a single matrix column using DAX measures. This is primarily a report design workaround to reduce horizontal sprawl. It’s relevant for Power BI UX, but doesn’t meaningfully impact Fabric architecture decisions.
Matrix text-consolidation pattern is DAX/report-level, not Fabric operational concerns.
Shows how filters in Calculate() on numeric columns—specifically when the filter value is 0—can alter execution behavior affecting performance. Practical because it ties a specific DAX pattern to storage-engine query generation and encourages measurement with DAX Studio server timings.
Investigates a DAX fusion/filter-on-0 pitfall with Calculate().
Explains a Power BI Desktop UI regression where icons render as solid black shapes due to a WebView2 runtime issue. It provides a temporary workaround by pinning WebView2 to a known-good version until the official fix ships. This matters operationally for teams doing demos, recordings, or walkthroughs during that window.
Regression due to WebView2; includes practical workaround to stabilize Desktop demos.
Chris Webb benchmarks how long large Image visuals take to render in published reports, even when underlying DAX is fast. He highlights that most time is spent in the Visual Container Resource Load event and that browser caching changes repeated loads.
Shows measurable Image visual load time using Performance Analyzer.
Shows how to use the Fabric Data Agent SDK by setting ai_skill_stage to sandbox (draft) vs production (published) and comparing responses for the same prompt. This directly supports disciplined prompt/version testing before rollout, reducing surprises in production behavior.
Provides a concrete approach to diff draft vs production AI agent outputs programmatically.
Discusses how Map visuals geocode location text via external services, which can become a major performance bottleneck. Includes a diagnostic approach using Performance Analyzer plus an option to bypass the geocoding cache for worst-case testing.
Geocoding latency can dominate map performance; includes cache bypass.
Analyzes how limited vs regular relationships behave and where performance penalties come from. It discusses cross–data island implications and execution-plan complexity. For a Fabric reader, this directly informs semantic model relationship choices and optimization strategies.
Performance comparison between regular and limited relationships informs model design.
Explains why DirectQuery reports can be slow even when DAX/topN appears selective, because the datasource SQL may return far more rows. Uses Performance Analyzer execution metrics (duration/rows read) to pinpoint the gap between DAX time and DirectQuery end time.
Diagnoses DirectQuery slowness from source queries returning huge resultsets.
Revisits centralized vs decentralized BI/model ownership as an AI-era continuation of older governance debates. For a Fabric architect, it reads as opinion with limited actionable guidance or measurable Fabric mechanics.
General architecture debate; lacks Fabric-specific operational detail.
Annual review of DAX developments in 2025, highlighting calendar-based time intelligence and preview UDFs. It focuses on developer impact and how code patterns may evolve, with limited actionable guidance. Useful for staying current, but not strong enough for production design decisions by itself.
High-level recap of DAX updates; lacks implementation or operational detail.
Shows how hitting Max Connections Per Data Source in DirectQuery causes queuing and perceived slowness. Uses Performance Analyzer to reproduce and observe the behavior when each underlying SQL query takes ~10 seconds.
Uses Performance Analyzer to validate DirectQuery connection-queueing.
Documents using the browser-based Performance Analyzer export (JSON) and building a “vibe-coded” custom visual to explore it. This is directly useful for systematic troubleshooting of published-report performance beyond Desktop-only workflows.
Turns Performance Analyzer JSON exports into a custom visual for analysis.
Proposes a semantic model and DAX measures to separate attributed vs influenced sales using many-to-many and dynamic CROSSFILTER. It’s a useful modeling pattern for marketing attribution scenarios. However, it’s largely Power BI modeling mechanics rather than Fabric-scale operational guidance.
Campaign attribution pattern is solid but not Fabric/Direct Lake/CU-focused.
Focuses on how admins can monitor usage of the Power BI Modeling MCP server by enabling Workspace Monitoring and querying SemanticModelLogs for MCP-PBIModeling calls. Key value is operational visibility for external tool activity when you can’t control the client identity.
Explains monitoring Modeling MCP usage via SemanticModelLogs and ApplicationName filtering.
Investigates whether Copilot answers questions using report visuals versus the semantic model when filters/slicers exist. It provides an experiment-style explanation and practical implications for getting consistent Copilot outputs.
Explores how Copilot answers change with slicers/filters presence.
Announces DAX Lib as an “app store” for sharing DAX user-defined functions via daxlib.org. For a production Fabric owner, the main value is discovering reusable model-independent UDFs and understanding integration options (e.g., Tabular Editor, .NET client). Governance, versioning, and cost/behavior implications of importing third-party DAX UDFs aren’t covered here.
DAX Lib UDF repository update; useful but mostly community tooling.
Explains that Copilot typically prefers answering from existing report visuals, which can be wrong in edge cases. Shows how AI Instructions can steer Copilot to bypass report visuals when generating answers.
Covers AI Instructions to prevent Copilot using report visuals.
Uses Dataflow Gen2 AI Functions to extract programming/query languages from text using a natural-language prompt. The automation is useful, but the post provides limited detail on evaluation, thresholds, or handling ambiguous extraction.
AI Functions example for extraction, but lacks quality metrics, failure modes, or guardrails.
Compares the newer RANK window function versus classic RANKX, focusing on performance and flexibility trade-offs. This is actionable DAX guidance for report authors, but it doesn’t map to Fabric-scale architectural decisions or operational concerns.
Ranking micro-optimization in DAX; not Fabric architecture-critical.
Chris Webb measures how the newer calendar-based time intelligence affects Power BI DirectQuery performance versus the older Mark as date table approach. The result is “on balance yes” but not clear-cut, implying different query shapes and backend behavior.
Benchmarks DirectQuery time intelligence with new calendar-based DAX; performance implications are nuanced.
This explains a common security misconception: users with access to a report but without Build permissions may still be able to access underlying semantic model data. It reinforces that only RLS/OLS (and related model security features) provide real data protection.
Clarifies Build permissions are not security; stresses need for RLS/OLS.
Defines model-dependent vs model-independent DAX UDFs and explains how dependencies affect portability and maintenance across semantic models. This is directly relevant when you standardize calculation logic and want safe reuse in Fabric CI/CD and governance. Strong “avoid hidden dependencies” guidance helps prevent brittle deployments.
Crucial UDF portability rules: model-dependent vs model-independent dependencies.
The post links DAX Studio Server Timings “Request ID” to Workspace Monitoring/Capacity Metrics OperationId using KQL. This enables faster operational diagnosis when testing multiple DAX queries against a semantic model.
Shows how DAX Studio request IDs correlate to Workspace Monitoring and Capacity Metrics app logs.
It answers whether Copilot can call a DAX UDF and provides an end-to-end example (ABC analysis) via a UDF definition. This is practical for enabling advanced semantic-model logic under Copilot, but it doesn’t deeply cover operational constraints.
Demonstrates calling DAX UDFs from Copilot; useful but not cost/governance heavy.
Describes using Semantic Link Labs to export a Power BI report to PDF, convert to images, and ask a multimodal LLM to detect page errors/accessibility issues. It’s a capability demo with practical steps, but not an architecture or validation playbook for production-scale scanning.
Interesting multimodal report QA idea, but privacy/accuracy evaluation and scale guidance missing.
Walks through building a measure to find products appearing in the top 10 across most years. It’s a detailed DAX pattern for a specific business question, with limited direct impact on Fabric platform architecture or operational monitoring.
Top-10/evergreen products DAX pattern; useful but narrow.
Chris Webb uses Workspace Monitoring/Log Analytics to capture the DAX generated when Copilot builds its text index. The revealed query patterns help you estimate operational impact and understand what model columns drive indexing work.
Uses Workspace Monitoring to reveal the exact DAX Copilot runs during text index builds.
This explains the warning caused by Copilot indexing limits across text columns and distinct text values. It also lists mitigation levers: reduce text columns/values and manage string lengths to stay under thresholds.
Breaks down Copilot “analyzed only part of the model” limits and what triggers them.
Explains when VALUES matters in SUMMARIZE group-bys, especially around blank rows from invalid relationships. Valuable correctness guidance for DAX authors, but it’s not about Fabric internals, scale, or capacity behavior.
VALUES-with-SUMMARIZE edge case; important DAX nuance but routine.
The article reviews Fabric Cost Analysis (FCA), a Fabric-based solution to monitor Azure/Fabric costs tied to capacities and operational changes (pause/resume, scaling, throttling side effects). For platform operators, it’s a FinOps-style tool discussion with emphasis on non-obvious cost drivers.
Covers Fabric Cost Analysis for tracking capacity-related and operational cost nuances.
Shows using Semantic Link Labs to set a DAX UDF using TOM and then list/use UDFs, including pulling expressions from DAX Lib repos. It’s valuable for reducing manual UDF drift, though it doesn’t deeply cover preview constraints, governance, or compatibility testing.
Automates DAX UDF creation/centralization via SLL, with preview limitations acknowledged.
It introduces Fabric Graph for analyzing refresh job graphs in Power BI Import mode, with a focus on dependencies and blocking/waiting. For practitioners, the value is building analytical models of refresh behavior rather than relying on UI-only debugging.
Explores Fabric Graph by analyzing Import refresh job dependency graphs.
Explains SUMMARIZECOLUMNS “value filter behavior” (Automatic/Independent/Coalesced) and why it changes filter combination semantics. It recommends setting Independent, introduced in 2025, to stay safe—highly relevant to preventing silent calculation regressions in model changes.
Value filter behavior guidance; recommends Independent to avoid subtle evaluation bugs.
Explains how Power BI adds Snowflake query tags (including an ActivityId/OperationId) and how to pivot that into Workspace Monitoring events. This is practical for tracing specific DAX-generated SQL back to report/visual context.
OperationID query tagging enables end-to-end debugging via Workspace Monitoring and Purview-adjacent logs.
Extends the OperationId/DMV approach from Power BI to Fabric Warehouse (T-SQL/SQL endpoint) and Spark jobs. Useful for admins who need to attribute warehouse or job activity to specific workloads in Capacity Metrics/Query Insights.
Shows how to correlate Fabric Warehouse/SQL Endpoint OperationId with Query Insights and Spark job details.
Details how Workspace Monitoring can identify throttled queries/refreshes by using OperationId (or XmlaRequestId in Log Analytics) and Execution Metrics’ capacityThrottlingMs. Strong operational guidance for capacity troubleshooting and spike investigations.
Uses Execution Metrics capacityThrottlingMs to quantify throttling delay per operation across monitoring surfaces.
Explains how to access Fabric Lakehouse data through OneLake SAS (short-lived user delegation) including workspace setting steps and generating SAS URLs for client-side apps. It’s operationally relevant for secure delegation scenarios, with a focus on auth/token handling rather than data modeling.
Provides delegated OneLake SAS access pattern for client apps via short-lived SAS URLs.
Introduces new calendar-based time intelligence functions in DAX, targeting non-Gregorian calendars. It emphasizes that the Date table must include specific year/month/quarter/week metadata columns for these functions to work. For a Fabric practitioner, it’s mostly a modeling contract change rather than a Direct Lake/capacity topic.
DAX preview feature; useful but not Fabric-specific or scalable-cost focused.
Introduces DAX user-defined functions introduced in September 2025: syntax, invocation, and reuse patterns. While it’s foundational, it matters for Fabric teams deciding how to standardize business logic and when to leverage repositories like DAX Lib. It doesn’t deeply cover operational governance beyond basic concepts.
Intro to DAX UDFs; sets foundation for reusable logic and reuse governance.
Discusses practical building blocks for using AI/agents with Power BI development, emphasizing context, LLM choice, and workflow design. For a Fabric operator, it’s mostly conceptual and doesn’t address tenant governance, evaluation determinism, or cost/latency/caching implications in enough detail.
AI/agentic development concepts; lacks concrete Fabric cost/governance guidance.
Reviews AI workflow/agent building blocks (model, context, prompt, tools, environment) for Power BI creators. Useful as framing for MCP/agent development thinking, but it reads like an initial/marketing-adjacent survey without strong Fabric operational guidance.
High-level AI workflows/agents overview; limited Fabric internals and cost/governance detail.
Explains how Direct Lake incremental framing works by reusing in-memory data and only reloading changed parquet files. Adds Semantic Link Labs delta_analyzer_history() to estimate the incremental framing effect from Delta log updates, helping predict refresh performance impact.
Quantifies incremental framing and shows how to estimate its effect via delta analyzer.
Explains when VALUES should be used inside iterators, focusing on behavior with valid vs invalid relationships. Key value is the blank-row inclusion semantics that can otherwise produce subtle measure bugs.
Clarifies VALUES-in-iterators semantics, especially blank rows from invalid relationships.
Outlines best practices for SUMMARIZECOLUMNS usage, emphasizing consistent evaluation through Value Filter Behavior settings. Directly applicable to complex models where query semantics and auto-exists/non-empty behaviors matter.
Practical SUMMARIZECOLUMNS best practices to avoid incorrect results via value filter behavior.
Describes how calling one calculation item from another can trigger sideways recursion, yielding unexpected results. Strong relevance for calculation group authors who need correctness controls.
Shows sideways recursion pitfalls in calculation groups with concrete example.
Announces/digests SQLBI+ updates around SUMMARIZECOLUMNS in measures, building from new Microsoft support and documenting behaviors. Useful, but it’s more of a course/package update than a standalone technical recommendation.
Updates on SUMMARIZECOLUMNS being fully supported in measures, with guidance trajectory.
Provides an advanced explanation of how SUMMARIZECOLUMNS constructs results and how to manage its behavior. Particularly valuable for diagnosing edge-case differences between intuitive grouping logic and actual engine scanning.
Internal mechanics of SUMMARIZECOLUMNS (auto-exists/clustering, non-empty, value filter) for control.
Proposes augmenting rule-based data quality checks with LLM-based contextual validation to catch impossible real-world combinations (e.g., clinical code vs patient demographics). The focus is on the first-pass analysis workflow using Fabric AI Functions, which can complement (not replace) existing DQ rules.
Introduces contextual data quality checks using AI Functions for anomaly semantics.
Reviews AI in the Power BI/Fabric context and introduces MCP servers with an LLM-driven demo controlling desktop/workspace items. Interesting for awareness, but it stays at the capability/story level rather than deep operational integration.
AI/MCP framing for Power BI; helpful conceptually, light on concrete Fabric cost/governance.
A perspective piece on why SQLBI is cautious about AI hype and how they aim to stay objective and durable. Mostly editorial; provides little actionable architecture, implementation, or governance detail.
Positioning/opinion on AI hype vs long-term BI value; not technical.
Covers the deprecation of Power BI default semantic models and provides two lab-based approaches to detect whether reports use default models and which semantic models have report attachments. This is directly useful for migration planning before the Aug 8, 2025 change.
Gives actionable SemLink Labs scripts to inventory reports using default semantic models.
Addresses a limitation: Polars/Delta-rs can’t directly read Delta tables with column mapping enabled. Provides a workaround that remaps logical to physical columns using transaction log + schema metadata, but warns about severe performance/parallelization loss.
Documents a workaround for reading column-mapping deltas with Polars/Delta-rs.
This post focuses on ALLSELECTED’s shadow filter context and its different behavior in SUMMARIZECOLUMNS vs iterators. It highlights how mixing patterns can yield unexpected results, which matters when you build complex filter-aware calculations.
Deep DAX ALLSELECTED pitfalls; useful for correctness, not Fabric-specific.
The article explains why DISTINCT and VALUES are not interchangeable, especially when blanks/invalid relationships enter the model. It provides rules of thumb to keep measures stable across data/model changes.
DISTINCT vs VALUES difference can affect resilience under bad data.
Describes using Semantic Link Labs to bulk apply Organizational Themes (preview/admin-only) to multiple Power BI reports by working with PBIR artifacts. The operational relevance is automating governance at scale, with notes about limitations (internal API usage and PBIR requirement).
Shows programmatic org theme application across many reports via Semantic Link Labs.
This article digs into how IF is evaluated in DAX across different scenarios by describing the translation into storage/formula engine execution. It’s valuable for understanding performance/correctness nuances, but it’s not directly tied to Fabric architecture.
General DAX evaluation mechanics; mainly optimization/conceptual learning.
Presents a “quick test” pipeline: export report pages as images to a lakehouse and use an LLM (Gemini multimodal) to detect broken visuals. It’s useful as a feasibility check for automation, but the approach is less deterministic than first-party model-based validation.
Experiments with multimodal LLM image-based detection of broken Power BI visuals.
Shows how to retrieve workspace activity events, store them in a lakehouse, and enrich them with geolocation derived from client IP using a KQL helper function. This is practical for monitoring/auditing RTI behaviors and understanding access patterns by geography.
Uses KQL geo_info_from_ip_address for IP-to-location auditing of workspace activity.
Explains how to run Fabric CLI commands from within a Fabric notebook, including authentication using notebook credentials. This supports automation and operational workflows, especially in constrained environments where external CLI installs aren’t feasible.
Demonstrates installing/using Fabric CLI inside notebooks with token-based auth.
It covers new calculation group properties (multipleOrEmptySelectionExpression and noSelectionExpression) to control behavior when users select none or multiple items. It also notes current preview constraints and the lack of UI, which affects how you operationalize it.
Calculation-group new properties handle empty/multiple selection edge cases.
Shows how Semantic Link Labs v0.9.11 introduces a copy_object() method for bulk copying semantic model objects between models/workspaces. Useful for automation-heavy migration scenarios, and it includes Python/TOM-based examples across Import and Direct Lake (where supported).
Semantic Link Labs adds object/property copying to streamline semantic model migrations.
Demonstrates using Fabric AI Functions to convert poorly structured/unstructured Excel sheets into structured tables, including handling layout variance and language differences. For this reader it’s an applied pattern, but the post excerpt suggests more implementation narrative than platform-level operational guidance.
AI-extraction for messy Excel is practical but lacks Fabric-specific cost/governance detail.
The post explains why unrelated-table fields in a matrix can trigger relationship errors or unexpected empty/subset outputs. It attributes the behavior to SUMMARIZECOLUMNS execution patterns (auto-exists/non-empty) and Power BI’s query construction.
Explains ‘can’t determine relationship’ matrix behavior via query construction.
This is a practical architecture recap comparing Import, Direct Lake, and Direct Lake+Import composite storage modes. It emphasizes refresh/model feature trade-offs, metadata transcoding/framing behavior, and typical fit—exactly the decisions you need for production planning.
Direct Lake/Import/Composite comparison with real refresh/model trade-offs.
The article surveys Power BI semantic-model/report tooling across the model/report lifecycle. It’s helpful orientation, but it’s not specific enough on Fabric scale, governance, or cost/behavior.
General overview of tools; no operational Fabric/scale guidance.
Announces an updated SQLBI+ course focused on implementing security in Tabular semantic models, with examples and a companion white paper. For a Fabric architect, it’s relevant if you need best-practice RLS/OLS design and performance-aware implementations.
Security patterns in tabular models; useful but gated behind SQLBI+.
A SQLBI course overview covering how to design a tabular security infrastructure, including RLS/OLS patterns and DAX implementation considerations. It matters because security planning affects model shape and can drive query/performance behavior.
Practical security-role implementation guidance; moderate Fabric relevance.
Shows how to build a dynamic Pareto calculation in Power BI using a numeric axis and slicer-driven measure selection. It’s a strong DAX/visual analytics technique, but it doesn’t inform Fabric capacity, model operations, or governance decisions.
Advanced DAX visualization technique; not Fabric platform internals.
It addresses time intelligence cases where Date-table auto REMOVEFILTERS breaks intended weekday filtering. The post proposes a technique to preserve specific filters while still computing time intelligence correctly.
Filter-preserving weekday logic is a common time-intelligence correctness trap.
A post summarizing tested insights and lessons from Direct Lake/Import changes announced at the Fabric Conference, including two Direct Lake flavors and calendar UDF topics. It matters because it affects architectural decisions around memory, fallback behavior, and security enforcement.
Direct Lake vs Import details plus security/memory fallback implications.
Describes a workflow for using AI tools to create Power BI custom visuals, emphasizing planning and validation. For a platform practitioner, it’s interesting only tangentially and doesn’t address Fabric operational concerns.
AI-assisted custom visuals process; mostly non-platform and cost/governance-light.
Shows how to implement conditional formatting via Power BI visual calculations, highlighting practical complexity and the feature’s applicability. This matters only insofar as you need to understand where visual calculations fit (and cost/maintainability implications) versus model measures.
Covers visual calculations for conditional formatting and their operational limits.
Documents a Feb 2025 Power BI Desktop issue where custom visual dialog/download APIs silently fail, plus Microsoft-confirmed fix rollout. Useful for production ops because it affects interactive UX and requires version pinning/upgrade planning.
Concrete Power BI Desktop regression affecting custom visuals dialogs, with fix version.
Presents an AR aging reporting approach and discusses why source schemas are often misfit for the problem. As a platform reader, you may reuse the modeling pattern thinking, but it doesn’t target Fabric/Direct Lake specifics.
AR aging modeling patterns; relevant conceptually but Power BI-specific.
Argues against the blanket “avoid pie charts” rule and provides nuanced exceptions. This is useful for design discussions but not for Fabric architecture, performance, or governance decisions.
Visualization opinion piece; low architectural or operational value.
Clarifies how ALLCROSSFILTERED behaves under CALCULATE, especially around cross-filtering and bidirectional relationships. While not Fabric-specific, this is directly useful for writing correct DAX in enterprise semantic models.
ALL vs ALLCROSSFILTERED distinction is actionable for advanced filter context control.
Shows how to optimize expensive running-sum inventory/balance calculations using snapshot tables and a hybrid approach. Relevant for scaling semantic queries, though it’s presented in a Power BI/DAX context rather than Fabric internals.
Incremental inventory performance strategy using snapshots and hybrids is genuinely optimization-focused.
Summarizes notable DAX/SQLBI updates in 2024, including new visual-calculation-only functions and INFO.* additions, plus community/event observations. Mostly awareness-level; helpful for planning DAX capability readiness but not a technical playbook.
Recap of DAX function additions and preview visual-calculation directions.
An article on reducing report maintenance effort by centralizing static formatting with theme files and conditional formatting with DAX measures. Useful for Power BI authors, but it doesn’t connect to Fabric internals, capacity, or semantic-model scale concerns.
Power BI visual/theme reuse advice; not Fabric-architecture or performance focused.
Lists new SQLBI+ sessions: an intro to Visual Calculations (preview) with noted limitations, and a practical overview of DAX performance tooling. Relevant as awareness for what to test and benchmark in models, but primarily content promotion.
SQLBI+ updates cover preview Visual Calculations and DAX optimization tooling.
Explains how blanks in date columns impact DAX time intelligence and what to do about missing/placeholder dates. Practical guidance for preventing subtle calculation errors and for hiding blanks when needed in visuals.
Blank date handling and time intelligence best practices affect model correctness.
A personal blog post about what SQLBI is working on (books/courses) and NDA timing. It’s useful for readers tracking content, but not actionable for Fabric/semantic architecture decisions.
Editorial about SQLBI roadmap and book/video publishing dates; no technical substance.
Discusses the “SQL database in Fabric” as a long-requested gap closure relative to Power BI Datamarts, and contrasts storage/provisioning/security expectations. For Fabric practitioners, the value is in deciding when to use Fabric SQL endpoints vs lakehouse/warehouse patterns.
Fabric SQL database vs Datamart/Lakehouse tradeoffs—impacts architecture choices.
Uses the open-orders/in-progress events pattern to compare a DAX-measure approach with visual calculations. It focuses on how visual calculations change computation strategy and why that can reduce work for this specific scenario—useful for performance experimentation.
Visual calculations vs DAX-only performance for an open-orders algorithm.
Explains how to use bullet charts to compare actuals vs targets, including build options and templates. For a Fabric platform architect, it’s visualization advice with limited relevance to Direct Lake/semantic/model performance.
Bullet chart guidance; mostly Power BI UX, not Fabric scaling concerns.
Discusses why week-based calendars are necessary for metrics sensitive to working days/weekends and how to implement alternatives in Power BI. It matters for semantic-model time intelligence correctness and avoiding misleading comparisons.
Week-based calendar handling and implications for YoY comparisons.
Discusses how VertiPaq is mostly datatype-neutral, but mixed datatypes in DAX expressions can trigger conversions that impact performance and sometimes rounding/precision. Useful for diagnosing “mysterious” slow measures and numeric discrepancies due to Currency vs floating decimals.
Explains DAX datatype conversions affecting precision and performance in VertiPaq expressions.
Shows a technique for creating complex visuals (matrix-like SVG timeline) using DAX measures, with explicit caveats about maintainability and real-world applicability. For a platform practitioner, the operational message is that these report-level tricks can add compute and change risk without much governance-friendly structure.
Custom SVG/image visuals via DAX measure; mostly Power BI report-logic complexity.
Provides an intuitive, visual framing of context transition (CALCULATE/CALCULATETABLE and implicit measure evaluation). While useful as reinforcement, it’s still core DAX pedagogy rather than Fabric-scale performance/architecture guidance.
Conceptual visual explanation of DAX context transition; foundational but not platform-specific.
Provides an architectural decision framework for choosing Direct Lake vs Import mode, including updated notes on mixing modes and calculated columns. This matters because the wrong choice can cause major rework in semantic transformations and performance characteristics.
Direct Lake vs Import mode guidance with updated mixing and efficiency thresholds.
Provides a detailed technical explanation of visual calculations implementation, including generated queries and new concepts like visual shape/context and virtual tables. Valuable for practitioners deciding when to delegate logic to visual calculations versus keeping it in the model.
Deep internals of visual calculations: virtual table, lattice, densification.
Covers formatting DAX measures/columns with static and dynamic format strings and highlights precision vs display behavior. It’s useful for report/model usability, but it’s not a Fabric performance, capacity, or governance decision topic.
Measure formatting guidance; no meaningful Fabric architecture impact.
Announces SQLBI+ subscription service for advanced DAX/modeling content. For this triage, it’s promotional and doesn’t include technical details, architectures, or measurable guidance.
Subscription marketing for SQLBI+; no technical substance or Fabric guidance.
Explains how to write DAX queries (EVALUATE, DEFINE, table expressions) for extraction, testing, and reuse. It’s occasionally useful for debugging/automation via DAX Studio or XMLA-connected workflows, but it’s not an enterprise Fabric architecture topic.
DAX query syntax basics; more tutorial than Fabric-specific architecture.
Deep-dive course material on Power BI composite models, including local/remote storage, query architecture, and security implications. This is directly relevant to choosing and maintaining mixed-storage semantic models in Fabric/Power BI.
Composite model internals map directly to real performance and design trade-offs.
Explains how two DAX implementations of the same business logic can yield slightly different results due to rounding and type conversions. This is directly applicable to semantic-model correctness and reconciliation in production reporting.
Rounding differences due to DAX data type conversions; directly relevant to correctness.
Summarizes early/preview SSAS Tabular features (e.g., integrated workspace, drillthrough control) plus DAX Studio updates. It’s interesting for Tabular history, but it’s not directly actionable for Fabric’s modern Direct Lake/semantic model ops.
SSAS Tabular vNext CTP notes; largely preview-era and not Fabric cost/ops.
Explains how RLS security role filters are evaluated and when the engine actually applies them. It highlights performance implications, including an updated bitmap index size limit (524,288 rows) affecting RLS costs in Power BI and related engines.
Quantifies RLS cost via bitmap index behavior; useful for capacity/perf planning.
A 2015 retrospective on Power BI’s rapid feature releases and improvements. It’s more commentary than engineering guidance, and it doesn’t address Fabric-era architecture, cost, or governance concerns.
Year-in-review Power BI status post; mostly strategy commentary without technical specifics.
Shows how to call DAX Formatter via GET/POST to format DAX queries, including updated MCP/nuget references. Handy for developer workflows, but not directly tied to Fabric architecture, capacity, or model performance.
DAX Formatter integration instructions; useful tooling, low Fabric impact.
Promotes an MDX cookbook for SSAS developers and highlights coverage of common MDX problems. Not relevant to modern Fabric/DAX/Direct Lake decision-making for this reader.
MDX Cookbook book promotion; irrelevant to Fabric internals.
This is a PASS Summit 2010 speaker announcement listing DAX-centric PowerPivot and SSAS monitoring/performance sessions. It’s useful historically for interests in DAX patterns and monitoring, but it doesn’t provide enough technical depth for production Fabric guidance.
Conference session list; no technical Fabric or deep implementation details.
Announces a book on SSAS 2008 Analysis Services cube development and lifecycle best practices. It’s dated and does not provide Fabric-relevant architectural or performance guidance.
SSAS 2008 cube-development book announcement; not actionable for Fabric work.
Documents an issue when using DRILLTHROUGH with a ROLAP dimension, including StorageMode changes and a duplicate attribute key error. While SSAS-specific, it’s a solid example of how modeling/storage choices can break drillthrough semantics and impose processing costs.
Deep SSAS drillthrough/ROLAP storage-mode bug behavior; tangential to Fabric but useful.
A long debate-like post uses a 1920s analogy to argue that BI systems need metadata and user control rather than central control. For a Fabric/semantic-model practitioner, it’s mostly historical opinion with limited actionable technical content.
Old blogging analogy; metadata-control discussion is not Fabric-relevant.