3. Start-to-Finish Study Path

Foundation: understand the Fabric data platform

Start with the Fabric object model:

• Workspace: collaboration and security boundary for Fabric items.
• OneLake: tenant-wide data lake foundation.
• Lakehouse: file/table-oriented engineering store backed by Delta tables and Spark.
• Warehouse: relational SQL analytics store for T-SQL developers and dimensional workloads.
• Eventhouse: real-time analytics store optimized for event/telemetry data and KQL.
• Data pipeline: orchestration, movement, scheduling, dependencies, parameters.
• Dataflow Gen2: low-code/no-code Power Query-based ingestion and transformation.
• Notebook: PySpark/SQL code-first transformation and engineering.
• Eventstream: real-time event ingestion and routing.

Foundation goal: when you see a requirement, you should immediately know the most likely Fabric item.

Intermediate: master ingestion and transformation decisions

Study these loading patterns:

• Full load for small or replaceable data.
• Incremental load with watermark for large changing data.
• Change data capture or mirroring when operational replication is required.
• Streaming ingestion for continuous events.
• Bronze/Silver/Gold pattern for lakehouse engineering.
• Dimensional modeling preparation for warehouse or BI consumption.

Intermediate goal: explain why one engine is better than another for a given scenario.

Advanced: governance, CI/CD, orchestration, and reliability

Focus on:

• Git integration for version control and pull-request workflows.
• Deployment pipelines for controlled promotion across dev/test/prod.
• Workspace roles and item permissions.
• Row-level, column-level, object-level, folder/file-level, and OneLake security.
• Sensitivity labels and endorsement.
• Fabric audit logs.
• Pipelines with parameters, dynamic expressions, retries, schedules, and event triggers.

Advanced goal: design a production-ready solution, not just a working data load.

Final review: monitoring and optimization

Practice recognizing symptoms:

• Slow Spark notebook: partitioning, shuffle, skew, file size, caching, job metrics.
• Slow warehouse query: statistics, distribution of joins, indexing/physical design where applicable, query plan, materialization strategy.
• Lakehouse table issue: Delta maintenance, compaction, vacuum retention, file layout.
• Pipeline failure: activity output, dependency, parameter, linked connection, schema drift, permission.
• Eventstream/Eventhouse issue: ingestion errors, schema mapping, retention, KQL function/windowing, throughput.

Final goal: when a question describes a failure, know where to look first and which fix is targeted.

4. Core Concepts by Domain

Domain 1: Implement and manage an analytics solution

Concepts

This domain tests whether you can configure and manage Fabric solutions as enterprise assets. It is not only about creating lakehouses or notebooks; it is about controlling how they are secured, promoted, governed, and orchestrated.

Key concepts:

• Workspace configuration for Spark, domains, OneLake, and Dataflows Gen2.
• Version control and collaboration with Git integration.
• Controlled deployment with deployment pipelines.
• Database projects for warehouse development lifecycle.
• Workspace-level and item-level access control.
• SQL security and OneLake security.
• Sensitivity labels, endorsement, and audit logs.
• Orchestration with pipelines, notebooks, parameters, dynamic expressions, schedules, and event triggers.

Services

Patterns

• Use Git integration for developer collaboration; use deployment pipelines for release promotion.
• Use workspace roles for broad collaboration access; use item permissions for specific artifacts.
• Use SQL row/column/object-level security for SQL access patterns; use OneLake security for file/folder/table access patterns in OneLake.
• Use pipelines as the orchestrator and call notebooks, Dataflows Gen2, copy activities, or stored procedures as steps.
• Use parameters and dynamic expressions to avoid hardcoding paths, dates, workspace names, and environment values.

Traps

• Choosing Git integration when the requirement is environment promotion and approvals. Correct answer is usually deployment pipeline.
• Choosing deployment pipeline when the requirement is pull requests and branch history. Correct answer is usually Git integration.
• Choosing workspace Admin when the user only needs to read one item. Prefer least privilege.
• Applying sensitivity labels when the requirement is to restrict rows. Sensitivity labels classify; they do not replace row-level security.
• Using a notebook as the orchestrator when the requirement is scheduling, dependency management, retries, and monitoring. Pipelines are usually the orchestrator.

Domain 2: Ingest and transform data

Concepts

This is the largest practical part of the exam because it tests service selection. The same data can often be transformed by Dataflows Gen2, notebooks, T-SQL, KQL, or pipelines. The exam wants the best fit.

Key concepts:

• Full, incremental, and streaming loading patterns.
• Watermark-based incremental ingestion.
• Dimensional model preparation.
• Lakehouse, warehouse, and Eventhouse selection.
• OneLake shortcuts versus physical copy.
• Mirroring for operational data replication.
• Batch ingestion with pipelines.
• Transformations using PySpark, SQL, and KQL.
• Handling duplicates, missing values, and late-arriving data.
• Eventstreams, Spark structured streaming, KQL processing, and windowing functions.

Services

Patterns

• Use watermarks for incremental batch loads. Store the last successful load timestamp or key.
• Use deduplication keys and event time when duplicate or late-arriving records are possible.
• Use Eventstream to ingest and route events; use Eventhouse/KQL to query and analyze event data.
• Use shortcuts when data should remain in place and be accessed through OneLake.
• Use copy/movement when you need physical control, transformation during landing, or isolation from source changes.
• Use mirroring when the requirement is operational database replication into Fabric with minimal ETL.
• Use lakehouse for engineering and open data layout; use warehouse for SQL-first curated analytics and dimensional modeling.

Traps

• Choosing a warehouse for raw semi-structured file engineering when a lakehouse/notebook pattern fits better.
• Choosing a notebook for simple low-code transformation when Dataflow Gen2 is enough and maintainable by analysts.
• Choosing Dataflow Gen2 for very complex PySpark logic, custom libraries, or distributed code workflows. Use notebooks.
• Choosing a shortcut when the requirement says transform and store a curated copy. Shortcut is access, not transformation.
• Choosing full load for large frequently changing data. Incremental with watermark is preferred.
• Ignoring late-arriving data in streaming questions. Use event-time windowing and proper watermarking logic.

Domain 3: Monitor and optimize an analytics solution

Concepts

This domain tests operational judgment. The exam often describes symptoms and asks what you should inspect or optimize.

Key concepts:

• Monitoring ingestion, transformation, and semantic model refresh.
• Pipeline run history, activity output, retries, and dependency diagnostics.
• Dataflow Gen2 refresh errors and transformation-step issues.
• Notebook execution errors, Spark job metrics, logs, and resource bottlenecks.
• Eventstream and Eventhouse ingestion/query errors.
• T-SQL error diagnosis and warehouse query tuning.
• OneLake shortcut errors caused by path, permission, source availability, or schema issues.
• Lakehouse table optimization, compaction, vacuuming, and query layout.
• Spark performance tuning: partitions, skew, shuffle, caching, file sizes.
• Warehouse and KQL query optimization.

Services and diagnostics

Patterns

• Diagnose before optimizing. The exam often rewards the answer that checks the specific run details or metrics first.
• For Spark, think: shuffle, partitions, skew, cache, file size.
• For lakehouse Delta tables, think: optimize/compact, vacuum carefully, partition wisely.
• For streaming, think: throughput, schema mapping, event-time windows, late data, retention.
• For pipelines, think: activity output, dependencies, retry policy, parameters, connections.
• For semantic model refresh, think: upstream availability, credentials, capacity, refresh history.

Traps

• Restarting capacity before checking run-level diagnostics. Capacity can be relevant, but exam questions often expect targeted troubleshooting first.
• Vacuuming as a universal fix. Vacuum removes old files; it can break time travel if retention is too aggressive.
• Partitioning by high-cardinality columns. It can create too many small files.
• Caching everything in Spark. Cache only reused intermediate data; otherwise it wastes memory.
• Optimizing the wrong layer: Spark tuning will not fix a SQL warehouse query plan problem, and warehouse tuning will not fix Eventhouse ingestion mapping.

5. Service Selection Guide

Lakehouse vs Warehouse vs Eventhouse

Dataflow Gen2 vs Notebook vs Pipeline

Shortcut vs Copy vs Mirroring

Batch vs Streaming transformation