Microsoft Fabric
SQL Server to Microsoft Fabric: What Maps to What?
A mental model for SQL Server professionals and DBAs moving into Microsoft Fabric: the closest Fabric equivalent of an instance, database, table, SQL Agent, SSIS, Query Store, tempdb and backups, where each DBA task goes, and where the mapping breaks down.
On this page
If you have spent years with SQL Server, your first hours in Microsoft Fabric are spent translating. Where is the server? Which thing is the database? Where do I schedule a job? Where is Query Store? What happened to tempdb?
Those are the right questions. This article answers them with a mental model, a concept map and reference tables, then explains the places where the mapping breaks, because that is where most early design mistakes come from.
Each mapping is labelled with how well it holds:
| Label | Meaning |
|---|---|
| Close match | The concept behaves the way a SQL Server professional expects, with small differences. |
| Partial match | Same purpose, different scope or behavior. Useful as a starting point, dangerous as an assumption. |
| Different model | The job still exists, but Fabric does it in a fundamentally different way. |
| No clean equivalent | There is nothing in Fabric you should map this to. Learn the new model instead. |
This guide assumes you know SQL Server well: instances, databases, schemas, SQL Agent, SSIS, Query Store, memory and CPU configuration, backups and high availability. It does not assume you know Fabric. If you want the platform overview first, read What Is Microsoft Fabric? and come back. Microsoft-documented facts are linked in Sources; the design advice is Javi Builds guidance.
The short answer
Five anchors carry most of the model:
- A workspace is not a database. It is a collaboration, project or environment container that holds many items and connects to Git.
- Warehouse, Lakehouse and SQL database are the database-level items. They are where schemas and tables live.
- A capacity is only partly like an instance. It is the pool of compute you pay for and run out of, shared by every workload assigned to it, not a SQL engine you configure.
- Capacity Units (CUs) are only approximately CPU and memory. They are a budget of compute measured over time, with smoothing and throttling, not cores you assign.
- OneLake is not MDF/NDF storage. Tables are Delta and Parquet files in one tenant-wide lake that every engine reads, not files you size and place.
For a DBA, that sorts the job into three groups:
| Stays familiar | Changes | Disappears or becomes Microsoft-managed |
|---|---|---|
| T-SQL, schemas, tables, views, procedures | Who owns compute: a shared capacity, not your instance | MDF/NDF and filegroup management |
| Query tuning: estimates, plans, reading less data | Storage: Delta tables in OneLake, with file layout to maintain | tempdb administration |
| Execution plans (now distributed in Warehouse) | Workspace boundaries for security, Git and environments | Patching, the OS and the SQL Server service |
| Workload monitoring and baselines | Orchestration: pipelines instead of SQL Agent | Always On and failover cluster administration |
Permission concepts: least privilege, groups, GRANT |
Spark and notebooks next to T-SQL; semantic models for BI | Most backup scheduling, replaced by item-specific recovery |
| Incident analysis and runbooks | Managing a SaaS platform: capacity, throttling, cost | Index rebuild jobs in Warehouse |
How much of each column applies depends on the item: SQL database in Fabric keeps more of the familiar column (indexes, tempdb managed by the service, the Azure SQL Database engine), while Warehouse and Lakehouse change more.
Two mental models side by side
SQL Server has a short hierarchy, and almost everything hangs off the instance. Fabric has more levels, and each one does a different job:
- SQL ServerServer first
- Instance / serverThe engine and its resources
- CPU and memory
- tempdb
- SQL Agent
- SSIS
- DatabaseFiles you size and back up
- Data and log files
- Query Store
- Backups
- Schema
- Table
- Microsoft FabricPlatform first
- TenantYour organization; one OneLake
- Partial · resources onlyCapacityShared Capacity Units, not a SQL engine
- Not a databaseWorkspaceProject, team or environment container
- Warehouse
- Lakehouse
- SQL database
- Pipeline
- Notebook
- Semantic model
- Report
- Closest to a databaseWarehouse · Lakehouse · SQL databaseThe data items, with their own structure
- Schema
- Table
- Delta tables
- Files
- OneLakeStorage under every data item
Read the Fabric column as:
- Capacity is shared compute. It is the closest thing to an instance only in resource terms: the pool of Capacity Units that every workload in its workspaces draws from.
- A workspace is organizational. It groups items, carries permissions, and is the unit that connects to Git and moves through deployment.
- Warehouse, Lakehouse and SQL database are the data items. They are the closest thing to “a database”.
- OneLake is the storage foundation. Every data item stores its tables there, mostly as Delta tables on Parquet files.
Inside a workspace, the items are siblings, and each data item has its own structure underneath:
- TenantYour Microsoft Entra organization; identity, settings, governance
- containsCapacityShared compute in Capacity Units; workspaces are assigned to it
- hostsWorkspaceTeam, project or environment container with roles and Git
- Data itemWarehouse
- Schema
- Table
- Data itemLakehouse
- Delta tables
- Files
- Data itemSQL database
- Schema
- Table
- Pipeline
- Notebook
- Semantic model
- Report
- data stored inOneLakeDelta and Parquet storage shared by every engine; SQL database replicates into it
A workspace is closer to a project, team or environment container. One workspace can hold several Warehouses, several Lakehouses, notebooks, pipelines, semantic models and reports. Its roles (Admin, Member, Contributor, Viewer) control who can work with the items, not which rows or tables someone reads. Workspaces are also the unit you connect to Git and separate into development, test and production.
The database-level concepts in Fabric are the data items:
| Workload | Closest to “a database” | Why |
|---|---|---|
| SQL-centric analytics, star schemas, T-SQL ELT | Warehouse | Full T-SQL read/write, schemas, tables, views, procedures, multi-table transactions |
| Spark, open files, Delta tables, data engineering | Lakehouse | Files and Delta tables, written by Spark, read through a SQL analytics endpoint |
| Transactional (OLTP) relational workloads | SQL database in Fabric | Built on the Azure SQL Database engine; data replicated into OneLake for analytics |
Match quality for “database”: Different model. Pick the item from the workload, not from the habit of “one database per application”. Microsoft Fabric Lakehouse vs Warehouse covers that decision in depth, and Create Your First Microsoft Fabric Workspace shows how workspaces are set up in practice.
The most important mental shift: stop thinking “server first”
In SQL Server, the instance is the center of the design: performance, security, storage, jobs and recovery are configured on it or on a database inside it. In Fabric, the platform, capacity, workspace and item are the architecture. Walk the same stack from the top when you design, and ask one question per layer:
- Tenant: who belongs to the organization, and which tenant settings and governance apply?
- Capacity: how much compute, in which region, isolated from what?
- Workspace: which team, project and environment, and who can work here?
- Item: Warehouse, Lakehouse, SQL database, notebook or pipeline?
- Data and compute engine: which engine (T-SQL, Spark, SQL database) writes and reads each table, and how is the data laid out?
- Consumption: how do semantic models, reports, APIs and downstream systems use the result?
A useful exercise is to take one SQL Server design question and ask which layer answers it in Fabric. “Isolate the reporting workload” is a capacity question. “Developers shouldn’t change production” is a workspace and deployment question. “This table is slow” is an engine and layout question. Designing a Scalable Microsoft Fabric Architecture applies this layering to a full platform.
Do not map these literally
Each of these shortcuts is tempting in the first week, and each one leads to a specific design mistake:
| Literal mapping | Why it breaks | Think of it as |
|---|---|---|
| Workspace = database | A workspace holds many data items, pipelines and reports, and its roles grant access to all of them | A project, team or environment container |
| Capacity = SQL Server instance | Nothing to configure (sp_configure, tempdb, logins); Spark, Warehouse, pipelines and Power BI all share it |
A shared, metered compute budget |
| CUs = cores and memory | Usage is smoothed over time and throttled in stages; you cannot pin a core to a workload | CU seconds consumed per operation |
| OneLake = SAN | It is a logical lake with one copy of the data for every engine, not block storage for one server | The storage layer under every data item |
| Lakehouse = SQL Server database | Spark writes it; its SQL analytics endpoint is read-only T-SQL | Files and Delta tables, with SQL on top |
| Delta table = MDF table | It is Parquet files plus a per-table log; every write adds files and a version | An open table format you maintain by layout |
| Pipeline = SQL Agent job | A pipeline orchestrates activities across items; schedules, alerts and history are separate pieces | One part of what Agent did |
| Notebook = stored procedure | A notebook runs in a Spark session with its own startup, scheduling and cost | Code for Spark-shaped work, called from a pipeline |
| Semantic model = table | It is the BI layer over tables: relationships, measures and storage mode | What Power BI queries, not where data lives |
Concept map at a glance
Where familiar concepts move, with the match quality on each Fabric concept. Data and compute first:
- Instance / server
- closestPartial matchCapacityResource analogy only
- CPU and memory
- closestPartial matchCapacity UnitsNo max server memory
- Database
- closestDifferent modelWarehouse · Lakehouse · SQL databaseData items, not the workspace
- Schema
- closestClose matchSchema
- Table
- closestClose or partialWarehouse table · Delta tableDepends on the engine
- MDF / NDF / LDF
- closestDifferent modelDelta tables in OneLakeFiles the engine manages
- tempdb
- no mappingNo clean equivalentNothing to configureEngine-managed temporary space
Then operations and monitoring:
- SQL Agent
- closestPartial matchPipeline and scheduleNothing migrates automatically
- SSIS
- closestDifferent modelData Factory · notebooksPipelines, Dataflow Gen2, T-SQL; Invoke SSIS Package (Preview) for some packages
- Query Store
- closestPartial matchQuery Insights · Capacity MetricsSplit across tools; no plan forcing
- PerfMon
- closestPartial matchCapacity Metrics appCU consumption and throttling, not OS counters
- Backup / restore
- closestDifferent modelItem-specific recoveryRestore points, PITR, time travel
- Availability Groups
- no mappingNo clean equivalentService-managed availabilityNothing to configure
The main mapping table
Scan it now and come back to it later; the sections after it explain the mappings that need more than a sentence.
Compute and infrastructure
| SQL Server concept | Closest Fabric concept | Match quality | Important difference |
|---|---|---|---|
| Instance / server | Fabric capacity | Partial match | A capacity is not a SQL engine. It is a pool of compute shared by Spark, Warehouse, pipelines, Power BI and other workloads in every workspace assigned to it. |
| CPU | Capacity Units (CUs) | Partial match | You buy an F SKU with a CU budget. Workloads consume CU seconds; you do not assign cores to a database. |
| Memory | Capacity Units, plus engine-managed memory | Partial match | There is no max server memory. Memory is managed per engine and per session; Spark sessions and Warehouse queries size themselves. |
| tempdb | Engine-managed temporary resources | No clean equivalent | Warehouse supports session-scoped #temp tables and spills internally, but there is nothing to size, place or tune. SQL database in Fabric has a tempdb that the service manages. |
| SQL Server service | The Fabric service itself (SaaS) | No clean equivalent | There is no service to start, stop or patch. You can pause and resume an F SKU capacity, which stops everything assigned to it. |
| Failover cluster / Availability Group | Service-managed availability | No clean equivalent | Infrastructure redundancy is handled by Microsoft. There are no replicas, listeners or failover modes to configure. |
Data structure
| SQL Server concept | Closest Fabric concept | Match quality | Important difference |
|---|---|---|---|
| Database | Warehouse, Lakehouse or SQL database in Fabric | Different model | Several data items can live in one workspace, and they can query each other with three-part names. |
| Schema | Schema | Close match | Warehouse schemas behave as expected. Lakehouse schemas exist too, but Spark is the writer. |
| Table | Warehouse table or Lakehouse Delta table | Close (Warehouse) / Partial (Lakehouse) | Both are Delta tables in OneLake. Warehouse tables are written by T-SQL; Lakehouse tables by Spark and other engines. |
| View | View | Close match | Supported in Warehouse and in the Lakehouse SQL analytics endpoint. |
| Stored procedure | Stored procedure | Close match | Supported in Warehouse. Some T-SQL features are not available, so test existing procedures before assuming they port. |
| Function | Function | Partial match | Supported in Warehouse; check the T-SQL surface area for the type you need. |
| Index | No user-managed indexes (Warehouse, Lakehouse) | Different model | Performance comes from file layout: V-Order, partitioning, compaction and, in Warehouse, data clustering (Preview). SQL database in Fabric keeps traditional indexes and automatic index creation. |
| Filegroup | None | No clean equivalent | Placement of data on storage is not your decision. |
| MDF / NDF | Delta and Parquet files in OneLake | Different model | Storage is files plus a transaction log per table, managed by the engine. |
| LDF / transaction log | Delta transaction log per table | Different model | The log is per table, not per database, and you never size, shrink or back it up. |
| Constraints (PK, FK, unique) | NOT ENFORCED constraints in Warehouse |
Partial match | Constraints document the model and can help the optimizer; they do not reject bad rows. |
| Triggers | None in Warehouse | No clean equivalent | Move the logic into the load process. |
Storage
| SQL Server concept | Closest Fabric concept | Match quality | Important difference |
|---|---|---|---|
| Local disks or SAN | OneLake | Different model | One logical data lake per tenant, built on Azure Data Lake Storage. Every engine reads the same copy. |
| Database files | Delta tables (Parquet files plus _delta_log) |
Different model | Open format, readable by Spark, T-SQL and Power BI without copying. |
Backup files (.bak) |
No user-accessible backup files | Different model | Recovery is item-specific: restore points, point-in-time restore, time travel, soft delete. |
ETL and orchestration
| SQL Server concept | Closest Fabric concept | Match quality | Important difference |
|---|---|---|---|
| SQL Agent job | Fabric pipeline | Partial match | Pipelines orchestrate activities across items. Nothing migrates automatically from msdb. |
| Job schedule | Pipeline or item schedule | Partial match | Pipelines, notebooks and other items have their own schedules. |
| Job steps and dependencies | Pipeline activities and dependency conditions | Partial match | Success, failure, completion and skip conditions replace step flow; Invoke pipeline replaces “start another job”. |
| SSIS | Data Factory pipelines, Copy activity or Copy job, Dataflow Gen2, notebooks, Warehouse T-SQL | Different model | No universal 1:1 replacement. The Invoke SSIS Package activity (Preview) runs some existing packages unchanged. |
| Linked server | Three-part names, shortcuts, mirroring, pipeline connections | No clean equivalent | Cross-item queries work inside Fabric. Reaching outside means copying, mirroring or a shortcut, not a live linked server. |
Monitoring and performance
| SQL Server concept | Closest Fabric concept | Match quality | Important difference |
|---|---|---|---|
| Query Store | Query Insights (Warehouse, SQL analytics endpoint) | Partial match | 30 days of completed-query history and aggregates, appearing up to about 15 minutes after a query ends. No plan forcing, and capacity behavior lives elsewhere. |
| DMVs | Fabric-supported DMVs and queryinsights views |
Partial match | sys.dm_exec_requests, sys.dm_exec_sessions, sys.dm_exec_connections and sys.dm_tran_locks exist in Warehouse, with workspace-role scoping. Many instance-level DMVs do not. |
| Wait statistics | Pool pressure in Query Insights, throttling in Capacity Metrics | No clean equivalent | There is no instance-wide wait stats view to read in Warehouse. Resource pressure shows up as capacity utilization and throttling. |
| Execution plans | SHOWPLAN_XML (Warehouse), Spark UI (notebooks) |
Partial match | Warehouse plans are distributed plans. Spark plans are a different discipline. |
| PerfMon | Microsoft Fabric Capacity Metrics app | Partial match | Capacity-wide CU consumption, smoothing and throttling, by item and operation. Not OS counters. |
| SQL Agent job history | Pipeline run history, Monitor hub | Partial match | Run history is per item and has retention limits; build your own execution log for long-term operations data. |
Security
| SQL Server concept | Closest Fabric concept | Match quality | Important difference |
|---|---|---|---|
| Server login | Microsoft Entra identity | Different model | No SQL authentication logins in Warehouse; users, groups and service principals come from Entra ID. |
| Database user | Item permission or workspace role | Partial match | CREATE USER is not supported in Warehouse; access starts at the workspace or item level. |
| Role | Workspace roles and T-SQL GRANT / DENY |
Partial match | Workspace roles are broad; object-level permissions in Warehouse narrow them. |
| Schema permission | Schema permission | Close match | GRANT ... ON SCHEMA works in Warehouse. |
Instance-level permissions (sysadmin, CONTROL SERVER) |
Fabric admin, capacity admin, workspace Admin | Different model | Administration is split between tenant, capacity and workspace roles. |
Reliability and operations
| SQL Server concept | Closest Fabric concept | Match quality | Important difference |
|---|---|---|---|
| Backup/restore | Item-specific recovery | Different model | See the backup section below; the options differ for Warehouse, Lakehouse and SQL database. |
| High availability | Service-managed | No clean equivalent | Storage uses zone-redundant storage where the region supports it. |
| Disaster recovery | Capacity disaster recovery setting plus your own recovery plan | Partial match | Optional geo-replication of OneLake data; recovering items in another region is still a procedure you own. |
| Patching | Microsoft-managed | No clean equivalent | The service updates itself. You still choose the Spark runtime version for notebooks. |
| Maintenance plans | Mostly automatic | Different model | Warehouse compacts and checkpoints automatically; Lakehouse table maintenance is yours. |
| Index maintenance | File layout maintenance | Different model | OPTIMIZE and VACUUM for Lakehouse tables; automatic compaction in Warehouse. |
| Statistics maintenance | Automatic, with manual single-column statistics | Partial match | Warehouse creates and refreshes statistics at query time; you can still create and update single-column statistics, but not multi-column ones. |
Instance → capacity: closest in resource terms only
The capacity is where the “server” intuition fits best, and only in one respect: it is the pool of compute you pay for and run out of. When a capacity is overloaded, everything assigned to it slows down or gets throttled, the same way an overloaded instance slows every database on it.
Everything else is different:
- A capacity is not a SQL engine: no
sp_configure, no tempdb, no logins. - Spark notebooks, Warehouse queries, pipelines, Dataflow Gen2, semantic model refreshes and report queries all share it.
- You size it by Capacity Units, not cores and memory. Workloads consume CU seconds, background work is smoothed over 24 hours, and throttling starts when sustained usage exceeds the capacity.
- Workspaces are assigned to capacities and can be moved. That is your isolation tool: production on one capacity, development on another.
The DBA question “how many cores does this need?” becomes “how many CU seconds does this workload consume, and when?”. Microsoft Fabric Capacity Explained covers CUs, smoothing and throttling in depth.
Operating a shared capacity
The operational differences matter more than the naming ones. On SQL Server, an overloaded instance gets slow. On Fabric, an overloaded capacity follows a documented, staged policy, and the work that pays is often not the work that caused it:
| On SQL Server you… | On a Fabric capacity |
|---|---|
| See CPU at 100% while the expensive query runs | Background work (pipelines, Spark jobs, refreshes, most Warehouse operations) is smoothed over 24 hours, so a heavy load can affect users hours later |
| Get slow queries under pressure | Throttling is staged: interactive requests are delayed after about 10 minutes of future capacity used up, rejected after 60 minutes, and background requests are rejected after 24 hours |
| Isolate workloads with Resource Governor or separate instances | Isolate by assigning workspaces to different capacities; workspaces on one capacity share its budget |
Tune concurrency with MAXDOP and memory grants |
Concurrency is managed per engine: Spark session limits and queueing, Warehouse resource pools. Many small concurrent jobs can cost more than one large one |
| Read PerfMon, wait stats and DMVs on one box | Read the Capacity Metrics app for CU by item and operation, then the engine’s own tools (Query Insights, Spark monitoring) |
| Buy hardware once and keep it busy | Choose an F SKU, pause or resize it, and trade capacity cost against workload scheduling and optimization |
For an investigation, the Fabric Capacity Saturation Runbook is the step-by-step procedure, and How I Diagnosed a Microsoft Fabric Capacity Saturation Problem shows one end to end. The Fabric Capacity Planner helps you interpret utilization and decide whether to optimize or scale, and Monitoring Fabric Pipelines and Notebooks covers the signals to keep between incidents.
Storage: you stop managing files, not layout
Tables are stored as Delta tables in OneLake: Parquet files plus a per-table transaction log (_delta_log), read by Warehouse, Spark, the SQL analytics endpoint and Power BI alike. SQL database in Fabric keeps its own engine storage and replicates into OneLake for analytics. File sizing, autogrowth, shrink and filegroups disappear.
What you still own is file layout. Many small files and unmaintained tables are the Fabric version of fragmentation. The Warehouse compacts automatically; in a Lakehouse, it is your job.
SQL Agent → pipelines and schedules
SQL Agent is a scheduler, a step runner, a dependency engine, an alerting system and a history store. In Fabric those jobs are split:
| SQL Agent job | Fabric home |
|---|---|
| Schedule | Pipeline schedule, or a schedule on the item itself (notebook, Dataflow Gen2, Copy job) |
| Job steps | Pipeline activities: Copy, Notebook, Script, Stored procedure, Invoke pipeline |
| Step flow (on success / on failure) | Activity dependency conditions |
| Operators and alerts | Pipeline notification activities, or alerting from your own monitoring |
| Job history | Pipeline run history and the Monitor hub |
Match quality: Partial match. Nothing migrates automatically; a job that ran T-SQL across databases on one instance often becomes a pipeline calling Warehouse stored procedures or a notebook. For the choice between the two, see Pipelines vs Notebooks vs Dataflow Gen2 vs Copy Job.
Run history is useful but not a long-term operations store. Most production teams add their own execution log; Designing an Execution Log for Microsoft Fabric Pipelines and Notebooks shows the design.
SSIS → there is no single answer
SSIS is the mapping SQL Server teams most want to be 1:1, and it is not. An SSIS package orchestrates, moves data, transforms it and logs what happened. In Fabric, those jobs usually belong to different items:
- Orchestration: pipelines
- Data movement: Copy activity or Copy job
- Row-level transformations: Dataflow Gen2 or notebooks
- Set-based SQL transformations: Warehouse T-SQL
- Running the existing package as it is: the Invoke SSIS Package activity, which is in Preview and has real limits on connectivity and custom components
Most estates end up with a mix: some packages retired, some rehosted, some rebuilt and some redesigned. Decide package by package. Migrate SSIS Packages to Microsoft Fabric gives you the responsibility map, an inventory and complexity score, migration waves and a cutover plan.
Query Store and DMVs → Query Insights plus monitoring
Query Store gives you, in one place, query history, runtime statistics, plan history, regressed queries and plan forcing. No single Fabric feature does all of that.
For Warehouse and the SQL analytics endpoint, the closest tool is Query Insights: views in the queryinsights schema that keep about 30 days of completed queries.
| You used to ask Query Store… | In Fabric Warehouse, look at… |
|---|---|
| Which queries ran, and how long did they take? | queryinsights.exec_requests_history |
| Which queries are consistently slow? | queryinsights.long_running_queries |
| Which queries run most often? | queryinsights.frequently_run_queries |
| Was the engine under resource pressure? | queryinsights.sql_pool_insights |
| Which queries use the most CPU? | allocated_cpu_time_ms in exec_requests_history |
Queries are grouped by shape through a query_hash. Completed queries can take up to about 15 minutes to appear (longer under heavy concurrency), and there is no plan forcing.
For live activity, Warehouse supports the query lifecycle DMVs you already know: sys.dm_exec_requests, sys.dm_exec_sessions and sys.dm_exec_connections. A workspace Admin sees every session; other roles see only their own. KILL works, and only for workspace Admins.
-- Longest-running active requests in a Fabric Warehouse
SELECT request_id, session_id, start_time, total_elapsed_time, status
FROM sys.dm_exec_requests
WHERE status = 'running'
ORDER BY total_elapsed_time DESC;For capacity-level behavior, what you used to read from PerfMon and wait statistics, use the Capacity Metrics app: which item and operation consumed the capacity, and were you throttled? Incident analysis usually needs both views.
SQL database in Fabric is the exception: it runs the Azure SQL Database engine, so more of your DMV knowledge applies directly, and its Performance Dashboard shows top CPU, memory, duration and blocked queries.
Match quality: Partial match. DMV knowledge transfers conceptually; the exact views differ. Compare How to Find SQL Server Performance Regressions with Query Store with Troubleshooting Microsoft Fabric Performance in Production.
tempdb: no clean equivalent
There is nothing in Fabric Warehouse or Lakehouse to map tempdb to, and it is better not to invent one.
- The Warehouse runs queries on a distributed engine that manages its own temporary storage and spills. You don’t configure files, size or placement.
- Session-scoped
#temptables are supported in the Warehouse, so the T-SQL pattern still works. - Spark has its own shuffle and spill behavior, managed per session.
- SQL database in Fabric does have a tempdb, because it is the Azure SQL Database engine, and the service manages it. Its Performance Dashboard even shows queries that spill to tempdb.
The instinct that transfers is diagnostic: a query that spills still has a bad estimate or too much data in flight. Fix the query or the data layout.
Backup and restore: platform-managed and item-specific
There is no single DBA-controlled backup model in Fabric, and no .bak workflow you can rely on across items. Fabric is a managed SaaS platform; durability is provided by the storage layer, and recovery depends on the item type.
| Item | What you get | What you don’t get |
|---|---|---|
| Warehouse | System restore points about every eight hours while the warehouse is active, user-defined restore points, 30-day retention by default (configurable from 1 to 120 days), restore in place, time travel queries, zero-copy table clones | Restoring to a new warehouse with a different name; backup files you can download |
| Lakehouse | Delta time travel to earlier table versions (until VACUUM removes old files), OneLake soft delete for files (seven days by default, configurable per workspace) |
A one-click point-in-time restore of the whole Lakehouse |
| SQL database in Fabric | Automatic full, differential and log backups, point-in-time restore within the retention period (7 days by default, up to 35), restore to a new database in the same workspace | Access to the backup files, cross-workspace restore, long-term retention |
“Restore last night’s backup” becomes a different procedure per item, with different retention. And definitions need their own protection: restore points protect Warehouse data, while Git protects notebooks, pipelines and object definitions. Git Integration in Microsoft Fabric covers how.
HA and DR: abstracted, not gone
Availability Groups, failover cluster instances and log shipping have no equivalent to configure. Infrastructure availability is part of the service. OneLake uses zone-redundant storage where the region supports it, and locally redundant storage elsewhere.
Disaster recovery is different. A capacity has an optional disaster recovery setting that replicates OneLake data to the paired Azure region, asynchronously and at file level. After a regional failover you recreate items in another capacity and workspace and recover data into them: a documented procedure, not an AG failover. The decisions move up a level: which capacity hosts production, whether DR is enabled, and whether definitions are in Git so they can be redeployed.
Warehouse is the easiest bridge for SQL Server people
The Fabric Warehouse feels familiar almost immediately:
- T-SQL for reads and writes
- Schemas, tables and views
- Stored procedures and functions
- Multi-statement transactions with
BEGIN TRANSACTION,COMMITandROLLBACK, including across tables - A relational model you design with star schemas and dimensional modeling
- Connection from SSMS, Visual Studio Code or any client that speaks TDS
That familiarity is also where assumptions hide. Before porting code, know what differs:
- Not every SQL Server feature exists. Triggers, synonyms,
SET TRANSACTION ISOLATION LEVEL, materialized views and recursive queries are among the documented limitations. Check the T-SQL surface area for your code. - Snapshot isolation only, with table-level locks. Any DML statement locks the whole table, and concurrent writers to the same table can conflict; you design load patterns, not locking hints.
- No traditional index management. No clustered or nonclustered indexes to create or rebuild. V-Order, automatic compaction and data clustering (Preview, defined when the table is created) do the layout work.
- Constraints are not enforced. Primary, unique and foreign keys require
NOT ENFORCED. Data quality checks move into the load process. - No MDF/NDF management and no SQL Server Agent inside the Warehouse. Storage is Delta in OneLake; scheduling lives in pipelines.
- Performance management is different. Statistics are automatic, the first run of a query can be slower because of a cold cache, and trickle inserts create many small files.
Start with Create Your First Fabric Warehouse with T-SQL, then read Lakehouse vs Warehouse before you decide where each layer of your platform lives.
Lakehouse is where the mental model changes
The Lakehouse is where genuinely new concepts start:
- Files and tables coexist: a
Filesarea for raw files and aTablesarea for Delta tables. - Delta tables are Parquet files plus a transaction log; every write creates new files and a new table version.
- OneLake stores both, and every Fabric engine reads the same copy.
- Spark (PySpark, Spark SQL) is the main writer, usually from notebooks.
- The SQL analytics endpoint gives read-only T-SQL over the tables: views yes,
INSERT,UPDATEandDELETEno.
| SQL Server table | Lakehouse Delta table | |
|---|---|---|
| Logical shape | Columns, types, rows | Columns, types, rows |
| Physical storage | Pages in MDF/NDF files | Parquet files plus _delta_log in OneLake |
| Writes | Row and page changes, logged in the database log | New files and a new table version per write |
| Readers | The SQL Server engine | Spark, SQL analytics endpoint, Warehouse, Power BI Direct Lake |
| Concurrency | Locks, optionally row versioning | Optimistic concurrency; conflicting writers fail and retry |
| Performance tools | Indexes, statistics, partitioning | File size, partitioning, V-Order, clustering, OPTIMIZE |
| History | Backups, temporal tables if configured | Time travel to earlier versions until VACUUM |
| Maintenance | Index and statistics jobs | OPTIMIZE and VACUUM |
The logical table is familiar; physical storage and compute are fundamentally different. Most Lakehouse performance problems come from treating a Delta table like a SQL Server table: many small writes, row-by-row updates, no maintenance.
Delta Tables in Microsoft Fabric for SQL Server Engineers builds this model properly. Explore Data with PySpark in Microsoft Fabric is the hands-on next step, and Delta Table Maintenance in Microsoft Fabric covers the maintenance you now own.
Where did my DBA task go?
Your job doesn’t vanish in Fabric; it moves. Some tasks disappear, some become Microsoft-managed, and some become Fabric architecture and operations tasks.
- Traditional DBA workConfigured on the instance and its databases
- goes awayNo longer your task
- SQL Server patching
- MDF/NDF growth
- tempdb configuration
- max server memory
- managedMicrosoft-managed
- Infrastructure availability
- Storage durability
- Service maintenance
- Warehouse compaction
- moves upFabric engineering work
- Capacity sizing
- Workspace architecture
- Workload isolation
- Orchestration
- Monitoring
- Cost management
- Security
- Deployment strategy
The table gives the detail, task by task:
| DBA task | Fabric status | What it becomes |
|---|---|---|
| Patch SQL Server | Microsoft-managed | Track Fabric release notes and choose Spark runtime versions deliberately |
Configure max server memory |
Disappears | Nothing to set in Warehouse or Lakehouse; SQL database has a maximum vCore setting |
| Configure tempdb | Disappears | Fix spills in the query or data layout |
| Add a data file, manage MDF/NDF growth | Disappears | Not the same storage model: watch OneLake storage and table file layout instead |
| Rebuild indexes | Changes | Lakehouse: OPTIMIZE, VACUUM, partitioning. Warehouse: automatic compaction, data clustering (Preview) |
| Update statistics | Mostly Microsoft-managed | Automatic in Warehouse; manual single-column statistics after large loads when needed |
| Inspect Query Store | Changes | Query Insights views in Warehouse and the SQL analytics endpoint; Spark monitoring for notebooks; the Performance Dashboard and Query Store views in SQL database |
| Troubleshoot high CPU | Changes | Start with the Capacity Metrics app (which item and operation used the CUs), then the engine: allocated_cpu_time_ms in Query Insights, or the Spark UI |
| Troubleshoot blocking | Changes, per engine | Warehouse: blocking_session_id in sys.dm_exec_requests and sys.dm_tran_locks still work, but DML locks the whole table, and concurrent writers can also fail with snapshot update conflicts. Keep transactions short and schedule DDL. SQL database keeps the familiar row-level model and DMVs. The SQL Server Blocking Runbook still applies there |
| Configure AG replicas | Disappears | No direct equivalent in Fabric SaaS workloads: decide on capacity DR and document item recovery |
| Backups | Microsoft-managed, item-specific | Know each item’s retention and restore procedure; keep definitions in Git |
| Schedule SQL Agent jobs | Changes | Pipelines, item schedules, dependency conditions, run monitoring |
| Capacity sizing | Becomes an architecture task | Choose F SKUs, separate workloads by capacity, plan for smoothing and throttling |
| Workload monitoring | Becomes an operations task | Query Insights, DMVs, Monitor hub, Capacity Metrics app, your own execution log |
| Security | Changes | Entra ID groups, workspace roles, item permissions, T-SQL GRANT, row- and column-level security |
| Cost monitoring | New | Capacity utilization, pause and resize decisions, storage growth |
The pattern: instance administration shrinks, platform operations grows. Monitoring Fabric Pipelines and Notebooks is a good place to start on the operations side.
Skills that transfer directly
SQL Server experience is a strong foundation for Fabric. The implementation changes; the engineering judgment transfers.
- SQL. T-SQL is first-class in the Warehouse and SQL analytics endpoint; Spark SQL is close.
- Data modeling. Star schemas, grain, slowly changing dimensions and keys matter as much as ever.
- Performance troubleshooting. Measure, find the expensive operation, change one thing, measure again.
- Query plans. Warehouse plans are distributed, but reading operators and estimates is the same skill.
- Transaction thinking. Atomic loads and idempotent retries decide whether a pipeline is safe to rerun.
- Security principles. Least privilege, groups over individuals, separation of duties.
- Indexing concepts as performance intuition. “Read less data” still rules; it now means partitioning, clustering and file pruning.
- ETL and orchestration concepts. Dependencies, restartability, incremental loads and error handling.
- Monitoring and capacity planning. Baselines, peaks and headroom; CUs are a new unit for the same reasoning.
- Production operations and incident analysis. Timelines, evidence, root cause and runbooks.
What should a SQL Server DBA learn first?
Learn in the order the platform makes decisions: containers and compute first, then data, then the code that moves it, then operations. Each step builds on the previous one:
| # | Learn | Why it comes here | Where to start |
|---|---|---|---|
| 1 | The workspace and item model | Every other decision happens inside it | Create Your First Microsoft Fabric Workspace |
| 2 | Capacity and CUs | The new unit for compute, cost, isolation and throttling | Microsoft Fabric Capacity Explained |
| 3 | OneLake | Where every table lives, and why engines share one copy | What Is Microsoft Fabric? |
| 4 | Warehouse | The shortest path from what you know | Create Your First Fabric Warehouse with T-SQL |
| 5 | Lakehouse and Delta | Where the storage model really changes | Delta Tables for SQL Server Engineers |
| 6 | Pipelines | What replaces SQL Agent and much of SSIS | Fabric Pipelines vs Notebooks |
| 7 | Notebooks and Spark basics | Enough PySpark to read, review and debug Lakehouse loads | Explore Data with PySpark |
| 8 | Monitoring | Capacity Metrics, Monitor hub, Query Insights, your own execution log | Monitoring Fabric Pipelines and Notebooks |
| 9 | Security and governance | Tenant, workspace, item and data-level controls | Microsoft Fabric Governance with Purview |
| 10 | CI/CD | Definitions in Git, promoted between environments | Git Integration and CI/CD with fabric-cicd |
Along the way, pick up Medallion architecture as the common way to layer raw, cleaned and serving data, and semantic models as the way Power BI consumes your tables. The Microsoft Fabric learning path puts all of it in a practical order, from an empty workspace to a production-ready platform.
Quick reference
Approximate mappings only. Use this to find your way, then read the section for the concept you are working on.
| SQL Server | Microsoft Fabric (approximate) | Match |
|---|---|---|
| Instance | Fabric capacity | Partial match |
| Database | Warehouse, Lakehouse or SQL database in Fabric | Different model |
| Schema | Schema | Close match |
| Table | Warehouse table or Lakehouse Delta table | Close / partial |
| MDF/NDF | Delta and Parquet files in OneLake | Different model |
| CPU and memory | Capacity Units | Partial match |
| SQL Agent | Pipeline and schedule | Partial match |
| SSIS | Data Factory, notebooks, Dataflow Gen2, Warehouse T-SQL, or Invoke SSIS Package (Preview) | Different model |
| Query Store | Query Insights plus monitoring | Partial match |
| PerfMon | Capacity Metrics app | Partial match |
| Backup/restore | Platform-managed, item-specific recovery | Different model |
| Availability Group | Service-managed availability | No clean equivalent |
| tempdb | Engine-managed | No clean equivalent |
| (nothing) | Workspace: a project, team or environment container, not a database | No clean equivalent |
What you learned
- Fabric concepts map to SQL Server only approximately; check the match quality before relying on a mapping.
- A capacity is the closest thing to an instance, in shared-compute terms only. A workspace is an organizational container, not a database. Warehouse, Lakehouse and SQL database are the database-level items.
- SQL Agent maps to pipelines and schedules, SSIS has no single replacement, and Query Store is split between Query Insights and capacity monitoring. tempdb, Availability Groups and
.bakbackups have no clean equivalent. - Your SQL, modeling, troubleshooting and operations skills transfer. OneLake, Delta, PySpark, pipelines, capacity and Git are what you add.
The next step is to build something. Create Your First Microsoft Fabric Workspace, then Create Your First Fabric Warehouse with T-SQL: the Warehouse is the shortest path from what you know to what Fabric does.
Sources
Microsoft-documented behavior in this article comes from these Microsoft Learn pages:
- Platform and capacity: Microsoft Fabric concepts and licenses, Workspaces, Workspace roles, Understand capacity throttling and smoothing, Capacity Metrics app
- Storage: OneLake overview, OneLake disaster recovery and data protection, Recover deleted files in OneLake
- Warehouse: What is Fabric Data Warehouse?, T-SQL surface area, Transactions, Primary, foreign and unique keys, Statistics, Data clustering (Preview), Temp tables, Query Insights, Monitor using DMVs, Troubleshoot query blocking, Restore in-place from a restore point, Smoothing and throttling for Warehouse
- Lakehouse: What is a lakehouse?, Delta table maintenance
- SQL database in Fabric: Overview, Automatic backups, Performance Dashboard
- Orchestration: Pipeline overview, Run, schedule, or use events to trigger a pipeline, Invoke SSIS Package activity (Preview)
The match-quality labels, the “do not map literally” list, the learning order and the operational comparisons are Javi Builds guidance, not Microsoft documentation.
Fabric behavior checked against Microsoft Learn in November 2026. Preview features (data clustering, Invoke SSIS Package) can change before general availability.
Was this helpful?
What could be better?
Thanks — that helps me improve Javi Builds.
Continue learning
- Cheat sheetKQL for Microsoft Fabric Cheat SheetThe Kusto Query Language (KQL) a Microsoft Fabric data engineer uses most in Eventhouse and KQL querysets: filter, shape, sort, summarize, time windows with bin(), joins, nulls and dynamic fields, with a SQL-to-KQL mapping and seven practice exercises.Open cheat sheet
- ArticlePower BI Visualization in Microsoft Fabric: From Semantic Model to Effective ReportHow to turn a governed Fabric semantic model into a Power BI report people act on: page hierarchy, visual choice, KPIs, drillthrough, accessibility and performance.Read article
What should I build next?
I'm building Javi Builds around practical problems data engineers actually face. Tell me what you'd like to see next.
Stay in the loop
Get the Javi Builds updates you actually care about.
Check your inbox
I sent you a confirmation link. Your subscription will be active after you confirm it.