Microsoft Fabric from a DBA's point of view: the good ideas and the sticking points
My opinion after the Fabric courses: bronze, silver, gold layers and Spark, yes; drag and drop, AI everywhere and workspace-level security, less so.
I took the Microsoft Fabric courses. It didn't click, but not everything should be thrown away. Here's my opinion as a DBA who prefers a script to boxes connected by arrows. It's an opinion, not the truth: a data scientist or a BI team will probably reach a different conclusion.
Fabric in two minutes
Fabric is a SaaS analytics platform: everything in one service, billed by capacity.
| Building block | Role |
|---|---|
| OneLake | A single data lake for the whole organisation. Data is stored in Delta (Parquet) format |
| Lakehouse | Files and Delta tables, mostly worked on with Spark, and readable in SQL through a read-only endpoint |
| Warehouse | A T-SQL data warehouse: tables, views, procedures, transactions |
| Data Factory | Orchestration pipelines and Dataflows Gen2 (Power Query), drag and drop |
| Spark notebooks | PySpark, Spark SQL, Scala… on the same data |
| Power BI | Reports, which can read OneLake directly (Direct Lake mode) |
| Copilot | AI, more or less everywhere in the interface |
What I like
- Bronze, silver and gold layers. Microsoft makes it the recommended architecture in Fabric: raw data, then cleaned, then ready to serve. The documentation even advises one workspace per layer, for better access control. It's a good idea, which I like everywhere, not only in Fabric.
- Spark with Python. Notebooks are real code: readable, testable, and there's a Git integration (Azure DevOps or GitHub) to version workspace items.
- A single copy of the data. Spark, SQL and Power BI read the same Delta tables in OneLake, without exporting all over the place.
A bronze-to-silver step, in PySpark in a notebook attached to a lakehouse:
from pyspark.sql import functions as F
bronze = spark.read.option("header", "true").csv("Files/raw/orders/") # raw, as received
silver = (bronze
.filter(F.col("order_id").isNotNull())
.dropDuplicates(["order_id"])
.withColumn("order_date", F.to_date("order_date")))
silver.write.format("delta").mode("overwrite").saveAsTable("silver_orders")
Eight lines, versionable, readable the next day. That's what I call ETL.
What gets stuck (for me)
- Drag and drop. Pipelines and Dataflows are built with the mouse. At first it looks nice. After a few months it's a plate of spaghetti: activities connected by arrows, logic hidden in property screens, and a code review that feels like spot-the-difference. To me, it's ETL for dummies.
- AI everywhere. Copilot suggests, generates, summarises. Great for getting started, less great when you need to understand what really runs in production.
- Security that's both too broad and too rigid. The front door is four workspace roles: Admin, Member, Contributor and Viewer. The first three read and write all the data in the workspace, and OneLake security roles (access by table, row or column) don't limit them: they only apply to Viewers and to users with read-only access to an item. On the other hand, a Viewer can run SQL queries but can neither open items nor run a notebook. Result: either you give too much or you block everything, and you end up multiplying workspaces to cope.
- Technically, nothing to write home about. Many product layers stacked on top of each other, and a DBA who likes to know what happens underneath often feels like looking through frosted glass.
My verdict
Fabric takes up good ideas: bronze, silver and gold layers, Spark, a single copy of the data. But the packaging (drag and drop, AI everywhere, coarse security) isn't made for me. Probably great for a data scientist or a BI team that wants to move fast; not my style. I've more or less dropped it, and we're still good friends.
The same ideas, with code: Data Vault, Snowflake and bronze, silver, gold layers.
Microsoft sources: