4.1 Storage Modes & Direct Lake
Key Takeaways
- Import caches a compressed copy in the VertiPaq engine for the fastest queries but needs a scheduled refresh and consumes capacity memory.
- DirectQuery stores no data and sends every visual interaction to the source as a live query, so data is current but speed is bounded by the source.
- Direct Lake reads Delta/Parquet files in OneLake directly into memory with no import copy, combining Import-class speed with near-real-time freshness.
- Direct Lake on OneLake does NOT fall back to DirectQuery; only Direct Lake on SQL endpoint falls back, and the Direct Lake behavior property controls it.
- Framing (a low-cost metadata refresh) points the model at the latest committed Parquet files; until reframed, queries can serve an older snapshot.
Why Storage Mode Is the First Modeling Decision
In the Implement and manage semantic models domain (25-30% of DP-600, tied as the second-largest after Prepare data at 45-50%), almost every model question opens with one choice: how the model holds its data. The exam tests whether you can match a storage mode to a scenario's freshness, performance, and source requirements, not merely define the modes.
A semantic model (formerly called a dataset) is the business layer that reports and analysts query with DAX (Data Analysis Expressions). Storage mode is a property of each table, so one model can mix modes. Microsoft Fabric processes Import and Direct Lake queries with the same in-memory VertiPaq engine, while DirectQuery federates the query to the source. That single fact explains most of the performance contrasts the exam draws between the three classic modes plus the Fabric-native option, Direct Lake.
Read every model scenario for three signals before you pick: where the data already lives (is it Delta in OneLake?), how fresh it must be (per-second, hourly, daily?), and how big it is relative to the capacity SKU. Those three drive nearly every correct answer.
The Three Storage Modes
Import copies source data into the model and compresses it column-by-column with VertiPaq. Queries are extremely fast because everything is memory-resident, but the data is only as fresh as the last refresh, and the model occupies capacity memory. Import is the only mode that supports incremental refresh, hybrid tables, and Power Query transformations baked into the model.
DirectQuery stores no data. Every slicer click, drill, or visual render becomes a live source query (warehouse, SQL database, etc.). Data is always current and the model stays tiny, but query speed is bounded by the source and its concurrency, and some DAX patterns are blocked.
Direct Lake is unique to Fabric. The model reads the Delta/Parquet files of a lakehouse or warehouse in OneLake straight into memory on demand, with no scheduled import copy. You get Import-class query speed with DirectQuery-class freshness, which is why Microsoft positions it as the default for lake-centric, IT-driven analytics (for example, the gold layer of a medallion architecture).
| Trait | Import | DirectQuery | Direct Lake |
|---|---|---|---|
| Where data sits | Cached in model | Stays in source | Delta in OneLake, paged to memory |
| Freshness | Last refresh | Live | Last framing (near real-time) |
| Query speed | Fastest | Source-bound | Import-class |
| Capacity license | Any (incl. free) | Any (incl. free) | Fabric F/P SKU only |
Framing and Fallback (Get the Nuance Right)
Two Direct Lake behaviors are heavily tested, and DP-600 rewards precision.
Framing is how Direct Lake decides which version of the Delta data it can serve from memory. A Direct Lake refresh is not a data copy at all; it copies only metadata, completing in seconds, and updates the model's pointers to the latest committed Parquet files. Until the model is reframed (manually, on a schedule, by automatic updates, or via the refresh API), queries can serve a slightly older snapshot even though OneLake already holds newer committed data.
Fallback is the trap most candidates miss. Direct Lake on OneLake does NOT fall back to DirectQuery — if a query cannot be served (for example, capacity guardrails are exceeded), the refresh fails and the model cannot be queried until the Delta tables are optimized. Only Direct Lake on SQL endpoint falls back to DirectQuery, in cases such as a non-materialized SQL view or SQL-based row-level security. The semantic-model Direct Lake behavior property (DirectLakeBehavior: Automatic, DirectLakeOnly, or DirectQueryOnly) controls that fallback.
So 'mixed performance, correct results' points to SQL-endpoint fallback, not to OneLake.
- Fallback query speed = DirectQuery speed, never Import speed.
- Excessive fallback is a tuning red flag — narrow the model and optimize Delta tables.
DirectQueryOnlyis a useful diagnostic to confirm a query can be answered without Direct Lake.
OneLake vs SQL Endpoint, and Capacity Guardrails
The two Direct Lake flavors differ in more than fallback:
| Capability | Direct Lake on OneLake | Direct Lake on SQL endpoint |
|---|---|---|
| Data sources | One or more Fabric items with Delta tables | A single lakehouse/warehouse |
| DirectQuery fallback | No | Yes |
| Composite with Import/DirectQuery/Dual | Yes (Import) | No |
| SQL-endpoint RLS/OLS inherited | No (OneLake file access) | Yes |
| SQL views | Not supported (use materialized view) | Yes (falls back to DirectQuery) |
Direct Lake also obeys per-SKU capacity guardrails that the exam can quote in disguise. Key thresholds: F2-F8 allow up to 300 million rows per table and a 10 GB model; F64/P1 raises this to 1,500 million (1.5 billion) rows and unlimited model size with 25 GB max memory; F256/P3 reaches 6 billion rows and 100 GB memory. If a Delta table exceeds these, the OneLake flavor's refresh fails while the SQL-endpoint flavor falls back. The exam cue 'model too big to load on F2' usually means scale the SKU or shrink the table, not 'switch to Import.'
When to Choose Each
Use this table to convert a scenario sentence into a mode.
| Requirement in the scenario | Best mode |
|---|---|
| Source already lands as Delta in a Fabric lakehouse/warehouse, need fast and fresh | Direct Lake |
| Need data from several Fabric items in one fast model, no fallback needed | Direct Lake on OneLake |
| Must inherit warehouse SQL row-level security or query a SQL view | Direct Lake on SQL endpoint |
| Data must be live every second from an operational SQL source not in OneLake | DirectQuery |
| Small/medium data, fastest possible visuals, daily freshness acceptable | Import |
| Large fact in Direct Lake/DirectQuery plus small Import dimensions | Composite model |
| Heavy Power Query transforms + complex DAX, no Fabric Delta source | Import |
Remember the licensing gate: Direct Lake requires a Fabric F (or legacy P) capacity, while Import and DirectQuery run on any license including free. A scenario that says 'free Power BI license' silently eliminates Direct Lake.
A Fabric semantic model uses Direct Lake on the SQL analytics endpoint. During month-end, some visuals slow noticeably while others stay fast, and all results remain correct. What is the most likely explanation?
New rows were written to a Direct Lake model's lakehouse Delta table 10 minutes ago, but a report still shows the older totals even though the model is healthy. What should you check first?