Direct Lake matches Import-level query performance once three conditions hold: the columns a query needs are resident in memory, the join indexes for those tables have already been built, and no part of the query falls back to DirectQuery. Miss any one of these and you see cold-start latency, slower joins, or SQL endpoint round-trips instead of VertiPaq speed. Fixing Delta file layout, sizing capacity correctly, and controlling fallback with the DirectLakeBehavior property is how you keep it that way.
TL;DR:
- Cold-start latency occurs when columns are not resident in memory, and join indexes are not yet built, which can significantly slow query performance.
- Regularly running table maintenance commands like OPTIMIZE and VACUUM helps reduce small files, fragmentation, and stale data, improving load times and join indexing speed.
- Fallback to DirectQuery happens if a table isn’t framed, unsupported features are used, capacity limits are exceeded, or memory pressure prevents data loading, impacting query speed.
- Setting the DirectLakeBehavior property appropriately during testing and production helps detect fallback issues early and manage latency risks effectively.
- Test query performance multiple times in different states to account for run-to-run variance driven by data locality, caching, and co-tenant load, ensuring reliable optimization.
Table of Contents
- How Direct Lake executes queries: framing, memory residency and join indexes
- Delta table and Parquet organisation that affects paging and load time
- DirectQuery fallback: triggers, DirectLakeBehavior property and recommended settings
- How to test and validate Direct Lake performance reproducibly
- Practical optimisation checklist for models, tables and capacity
- Operational issues: concurrency, runtime variance and cost trade-offs
- A consultant’s view on what actually moves the needle
- Security and access control considerations affecting performance
- Choosing the right engine for the job
- Tuning Direct Lake performance with hands-on Microsoft Fabric support
- FAQ
- Sources
How Direct Lake executes queries: framing, memory residency and join indexes
Every Direct Lake semantic model relies on a process called framing. Framing updates the model’s metadata to point at the current set of Delta table parquet files without physically copying data into the model. Incremental framing, which only updates the metadata for changed files, is lightweight and fast. Full framing recalculates everything and costs more, which matters if you trigger it too often during a refresh cycle.
Once framing completes, the engine still has to load columns on demand. The first query against a table pulls the required columns from Parquet into memory; subsequent queries against those same columns run at VertiPaq speed because the data is already resident. This is the mechanism behind the “cold versus warm” distinction that shows up repeatedly in Direct Lake discussions: the first user after a refresh pays a tax that nobody after them pays at least until eviction forces a reload.
Join indexes add a second layer of cold-start cost. Direct Lake models build join indexes between related tables the first time a query needs that relationship, rather than at refresh time. Recent engine updates parallelise this build process, which cuts first-query latency meaningfully, but tables with high-cardinality join columns still take longer to index than low-cardinality ones.
A few practical levers reduce the pain of both cold starts:
- Reduce cardinality on join keys where the business logic allows it, since smaller distinct-value sets build indexes faster.
- Pre-warm the model after each refresh by running a small set of representative queries before end users arrive.
- Limit the columns referenced by default-loading visuals so the first paint doesn’t force every column into memory at once.
- Avoid unnecessary bidirectional relationships, since they multiply the join-index work the engine has to do.
None of this changes how Direct Lake works structurally. It changes how much of the cold-start tax your users actually feel.
Delta table and Parquet organisation that affects paging and load time
File layout is where most avoidable Direct Lake latency hides. A Delta table scattered across hundreds of small parquet files forces the engine to open and read metadata from each one, and that overhead compounds every time a column gets loaded. Many small row groups inside those files make it worse, because the engine has to stitch together more fragments to reconstruct a single column in memory.

V-Order, Microsoft Fabric’s write-time optimisation, sorts and compresses data so that the VertiPaq engine can read it more efficiently once loaded. Dictionary encoding on low-cardinality columns reduces both storage and load time; without it, repeated text values get stored in full rather than as compact references, and column loads take longer than they need to.
The fix is routine table maintenance, not a one-off project:
- Run
OPTIMIZEregularly to compact small files into fewer, larger ones, targeting files in the low hundreds of megabytes rather than tens of kilobytes. - Run
VACUUMafter deletions and updates to clear stale file versions that otherwise bloat storage and confuse file-selection logic. - Keep row-group sizes balanced: large enough to reduce fragmentation, small enough that memory use during a scan stays reasonable.
- Check file counts and sizes periodically using the Lakehouse’s built-in table details view, rather than waiting for users to report slow dashboards.
Pro Tip: Schedule OPTIMIZE immediately after your incremental refresh job, not before it, so you compact the files that the refresh just wrote rather than stale ones from the prior run.
Prioritise maintenance on your largest, most frequently queried fact tables first. A compaction job on a rarely touched dimension table buys you nothing; the same job on a billion-row fact table queried every morning changes how that first query feels.
DirectQuery fallback: triggers, DirectLakeBehavior property and recommended settings
Direct Lake falls back to DirectQuery when it cannot serve a query directly from VertiPaq, and the causes are specific enough to check for one by one. Microsoft’s documentation lists the main triggers:
- A table hasn’t been framed yet, so there’s no current metadata pointing to usable parquet files.
- A query uses a feature Direct Lake doesn’t support at the storage layer, such as certain SQL views or row-level and object-level security defined at the SQL analytics endpoint.
- The query or model breaches a capacity SKU guardrail, such as row count or table size limits for that tier.
- Memory pressure on the capacity prevents the required columns from loading, forcing the engine to route the query elsewhere.
The DirectLakeBehavior property, set at the semantic model level, gives you three ways to control this. Automatic lets the engine fall back silently when needed, which is the safest default for production but can mask problems you’d rather know about during development. DirectLakeOnly forces every query through Direct Lake and fails outright if it can’t, which is exactly what you want while building a model, because it surfaces unprocessed tables and unsupported features immediately rather than hiding them behind a slower but working query. DirectQueryOnly forces every query through the SQL analytics endpoint, which is useful specifically for benchmarking what fallback actually costs you.
A practical pattern that works across most engagements: author and test with DirectLakeOnly so nothing silently falls back while you’re building, switch to DirectQueryOnly briefly to measure worst-case latency, then decide whether Automatic in production is acceptable based on how large that gap turns out to be. If DirectQuery fallback adds seconds rather than milliseconds, you need to fix the trigger, not tolerate the fallback.
How to test and validate Direct Lake performance reproducibly
Direct Lake performance claims mean little without a repeatable test plan, because cold-start and warm-state behaviour look completely different on the same model.
- Cold-start test: clear the model from memory (or wait for natural eviction), then run your critical visuals and record the first-query duration, including join-index build time.
- Warm-state test: run the same visuals again immediately after, with columns and indexes already resident, and record the difference.
- Concurrency test: run the same queries from multiple sessions simultaneously to see how capacity contention affects duration under realistic load.
- Incremental refresh impact test: run your test queries immediately after a scheduled refresh to see how much framing and re-indexing cost adds to the next user’s experience.
Two tools do the actual measurement. Performance Analyzer in Power BI Desktop or the Service shows per-visual timings and flags whether a query ran through DirectQuery rather than Direct Lake. SQL Server Profiler, connected to the semantic model, lets you watch for DirectQuery_Begin and DirectQuery_End events alongside VertiPaq_SE_Query events; seeing DirectQuery events where you expected pure Direct Lake is the clearest possible sign that something triggered a fallback.
Toggling the DirectLakeBehavior property between DirectLakeOnly and DirectQueryOnly during these tests isolates the two code paths cleanly, so you’re comparing like with like rather than guessing which path a given query took.
Run-to-run runtime variance in distributed lakehouse queries can be nearly twofold, driven by data locality, co-tenant load and caching effects, according to research on query performance prediction for lakehouse systems. That variance is a reason to run every test multiple times rather than trusting a single measurement; a query that took 400 milliseconds once and 700 milliseconds the next run hasn’t necessarily regressed, it may simply be exhibiting the variance the research describes.
Record four numbers for every test: total query duration, join-index build time where applicable, capacity unit (CU) consumption from the Fabric Capacity Metrics app, and run-to-run variance across at least three repetitions. Without those four, you have an anecdote rather than a baseline.
Practical optimisation checklist for models, tables and capacity
Most Direct Lake performance problems trace back to a small number of fixable decisions made during modelling, maintenance or capacity planning.
On the model side:
- Reduce high-cardinality joins used directly in visuals, since each one adds join-index build cost at cold start.
- Pre-aggregate where the business question allows it, so visuals query smaller summary tables instead of raw fact tables.
- Limit the columns referenced by default-loading visuals, which reduces how much has to load into memory before the first dashboard paints.
- Avoid unnecessary calculated columns at the model layer when the same logic can live in the Delta table itself.
On table maintenance:
- Run
OPTIMIZEon a schedule tied to your refresh cadence, not ad hoc, so file counts stay low between runs. - Control row-group sizes during writes rather than leaving defaults that produce excessive fragmentation.
- Maintain dictionary encoding on low-cardinality text columns to keep column loads fast.
- Run
VACUUMafter bulk deletions or updates so stale file versions don’t accumulate and slow file selection.
On capacity:
- Monitor CU consumption through the Fabric Capacity Metrics app to spot hot timepoints before users notice slowdowns.
- Use autoscale where load is genuinely unpredictable, rather than over-provisioning a fixed SKU for peak load that rarely occurs.
- Consider a SKU upgrade when guardrail breaches happen consistently rather than occasionally, since repeated fallback from guardrail limits is a capacity problem, not a modelling one.
On runtime behaviour:
- Schedule a small batch of warm-up queries immediately after framing completes and before your peak usage window begins, so the first real user doesn’t pay the cold-start cost.
Pro Tip: Treat your warm-up queries as part of the refresh pipeline, not an afterthought; a scheduled pipeline step that runs five representative DAX queries costs almost nothing and removes the worst of the cold-start experience for your first users of the day.
None of these items works in isolation. A well-modelled table on an under-sized capacity still breaches guardrails; a well-sized capacity running against poorly compacted parquet files still pages excessively. Treat the checklist as a set, not a menu.
Operational issues: concurrency, runtime variance and cost trade-offs
Even a well-tuned Direct Lake model shows runtime variance under real concurrent load, and that variance has measurable causes rather than being random noise. Research into query performance prediction for lakehouse systems found that run-to-run variance in distributed lakehouse queries can be nearly twofold, driven by data locality, co-tenant interference on shared infrastructure, and caching effects that differ depending on what else ran immediately before your query.
Reducing that variance in practice means:
- Isolating genuinely critical workloads onto dedicated capacity rather than sharing a SKU with unrelated, unpredictable workloads.
- Staggering heavy background jobs, such as large refreshes or
OPTIMIZEoperations, away from peak query hours. - Treating caching behaviour as a variable to test for, not assume, since a query’s speed can depend on what ran just before it.
The cost trade-off is genuine. Autoscale absorbs unpredictable spikes without manual intervention but costs more during those spikes. A higher fixed SKU avoids guardrail breaches outright but means paying for headroom you may rarely use. Workload scheduling, moving heavy jobs to off-peak windows, costs nothing extra but requires discipline and monitoring to enforce.
Watch for three signals that something is wrong: sustained high CU usage with no corresponding increase in query volume (a sign of inefficient queries or missing maintenance), queries that alternate between fast and slow with no code change (a sign of contention or caching inconsistency), and repeated DirectQuery fallback events appearing in Profiler traces during periods of otherwise normal load (a sign of guardrail or memory pressure rather than a one-off fluke).
A consultant’s view on what actually moves the needle
Working through Direct Lake performance issues with organisations migrating from Import mode, the pattern repeats: teams assume Direct Lake is slow when the real cause is an unoptimised Delta table or a silent DirectQuery fallback nobody noticed. Typical engagements follow the same arc: an audit against the checklist above, targeted table maintenance and model adjustments, then a measurable before-and-after comparison using Performance Analyzer traces and CU figures from the Capacity Metrics app.
That audit-to-optimisation path maps directly onto the diagnostics covered in this piece: check framing and join-index build times first, fix file layout second, then address capacity sizing and fallback configuration last, because fixing capacity without fixing the underlying table layout just delays the same problem.
Security and access control considerations affecting performance
Security configuration in Direct Lake models isn’t purely a governance concern; it has a direct line to query performance. Row-level security (RLS) and object-level security (OLS) defined within the semantic model itself are evaluated by VertiPaq and stay within the Direct Lake query path. Security enforced at the SQL analytics endpoint, however, is one of the documented triggers for DirectQuery fallback, because Direct Lake’s storage-layer query path doesn’t support every SQL-level security feature.
This means a security design decision made for governance reasons can silently cost you Direct Lake’s speed advantage. A table secured with SQL-level RLS that would otherwise serve queries through VertiPaq instead routes through DirectQuery every time, and that fallback often goes unnoticed until someone checks Profiler traces or Performance Analyzer output.
The practical guidance is straightforward: implement RLS and OLS at the semantic model level wherever the business requirement allows it, and reserve SQL-level security for cases where it’s genuinely required, such as controlling access for tools that query the SQL analytics endpoint directly rather than through the semantic model. When SQL-level security is unavoidable, treat the resulting fallback as expected rather than mysterious, and budget for the latency difference in your testing rather than discovering it in production.
Choosing the right engine for the job
Direct Lake earns its place when data volumes are large, freshness matters, and your team is willing to maintain Delta table layout and monitor capacity properly. It falls short of its promise when nobody owns table maintenance or when capacity is under-sized for the workload.
Import still wins for small, predictable datasets where sub-second consistency matters more than freshness, because there’s no framing, no cold start, and no fallback risk to manage. DirectQuery earns its place only where live-source constraints genuinely require it, accepting its latency as the cost of real-time accuracy.
For most BI developers working with growing lakehouse data, Direct Lake is the right default, provided the maintenance discipline described above comes with it. Skip that discipline and you’re better off with Import until you’re ready to commit to it.
— Michael
Tuning Direct Lake performance with hands-on Microsoft Fabric support
Diagnosing cold-start latency, fallback triggers and capacity guardrails takes time most internal teams don’t have spare, and getting it wrong means shipping a dashboard that feels slower than the Import-mode report it replaced. We provide hands-on support through the full engagement, auditing framing behaviour, Delta table layout and capacity configuration, then implementing the fixes rather than just handing over a report.

That includes Direct Lake tuning, Fabric capacity planning, and the architecture decisions that determine whether a model falls back to DirectQuery under load. If your dashboards are slower than they should be, or you’re migrating from Import and want it done right the first time, start with our Microsoft Fabric consulting services page and book an audit of your current model.
FAQ
What are the limitations of Direct Lake?
Direct Lake falls back to DirectQuery when a table isn’t framed, when a query uses unsupported SQL-level features such as certain views or SQL-level security, or when a capacity SKU guardrail is breached, according to Microsoft’s Direct Lake documentation. It also carries a cold-start cost the first time columns and join indexes load into memory after a refresh.
How does Direct Lake work?
Direct Lake reads columns directly from Delta table parquet files using the VertiPaq engine, loading only the columns a query actually needs rather than copying the full dataset into memory, as Microsoft explains. Framing updates the model’s metadata to point at current files, and join indexes build the first time a relationship is queried.
What are the key differences between Direct Lake and OneLake?
OneLake is the single, tenant-wide storage layer in Microsoft Fabric that holds Delta tables in Parquet format, while Direct Lake is the query mode that reads those tables directly into a semantic model without a separate import step, per Microsoft’s overview. One is storage, the other is how a semantic model accesses that storage.
How do I test for DirectQuery fallback before going to production?
Set the DirectLakeBehavior property to DirectLakeOnly during development so any fallback trigger causes a visible failure instead of a silent, slower query. Use Performance Analyzer and SQL Server Profiler’s DirectQuery_Begin/DirectQuery_End events to confirm which path a query actually took, as described in Microsoft’s query processing guidance.
Why does the same Direct Lake query run at different speeds each time?
Run-to-run variance in distributed lakehouse queries can be nearly twofold due to data locality, co-tenant load and caching effects, according to research on lakehouse query performance prediction. Running tests multiple times and isolating critical workloads on dedicated capacity reduces how much that variance affects production users.
Sources
- How Direct Lake works – Microsoft Fabric
- Direct Lake Performance Gets a Boost: Faster join index creation – DAX Tips
- Runtime variance and its impact on QPP for lakehouse systems