Microsoft Fabric

Create Your First Fabric Lakehouse

Create a Microsoft Fabric Lakehouse step by step and understand Files vs Tables, Delta Lake, schemas, the SQL analytics endpoint and where your data actually lives in OneLake.

By JaviPublished 10 min readBeginner

The Lakehouse is where most Microsoft Fabric data engineering starts. It is the place raw files land, where Spark writes Delta tables, and where SQL users and Power BI read curated data, all without copying it between systems.

In this tutorial you create lh_learning in the jb-fabric-dev workspace, explore its two storage areas, look at the SQL analytics endpoint Fabric creates for you, and find out where the data physically lives in OneLake. You will not load real data yet; that happens in the next tutorial, from a notebook. The goal here is to understand the structure you are going to write into.

This tutorial continues from Connect Microsoft Fabric to Git. If you skipped Git, everything still works; you just will not have the commit step at the end.

What a Lakehouse is

A Lakehouse combines the flexibility of a data lake with the structure of a database:

  • like a data lake, it stores files of any format cheaply and at scale;
  • like a database, it exposes tables with schemas that SQL and BI tools can query.

In Fabric, a Lakehouse is an item in a workspace. Its data is stored in OneLake, Spark is its native read-write engine, and every Lakehouse comes with a SQL analytics endpoint for T-SQL reads.

Files vs Tables

Every Lakehouse has two top-level areas. Understanding the difference is most of what you need on day one.

  • Files

    Unmanaged area

    • Any format: CSV, JSON, Parquet, images
    • Folders you organize yourself
    • Read with Spark or pandas by path
    • Not visible as tables to SQL

    Use for landing raw files and anything that is not a table yet.

  • Tables

    Managed area

    • Delta Lake tables
    • Grouped in schemas, dbo by default
    • Queryable from Spark, T-SQL and Power BI
    • Schema, history and ACID writes

    Use for data that people and processes query as tables.

Files hold data as it arrived; Tables hold managed Delta tables that every Fabric engine can query.

Files is a file system. You decide the folder layout, and Fabric does not interpret what you put there. It is the right place for raw extracts, partner drops and anything you want to keep exactly as it arrived.

Tables is managed. Anything written there in Delta format is registered as a table and becomes queryable from Spark, from T-SQL through the SQL analytics endpoint, and from Power BI. If you put something that is not a Delta table under Tables, Fabric shows it as unidentified instead of guessing.

Delta Lake in one paragraph

Lakehouse tables use the open Delta Lake format: data stored as Parquet files, plus a _delta_log folder containing a transaction log. The log is what turns a folder of files into a table. It records every write as a versioned commit, which gives you atomic writes, schema enforcement, and the ability to read an earlier version of the table. Because the format is open, Spark, the Fabric SQL engine and Power BI’s Direct Lake mode all read the same files. Delta Tables in Microsoft Fabric for SQL Server Engineers explains the format against SQL Server tables, and the Delta Lake hub goes deeper when you need it.

Create the Lakehouse

1. Open the workspace

In the Fabric portal, select Workspaces and open jb-fabric-dev.

2. Create the Lakehouse

  1. Create a new item in the workspace and choose Lakehouse as the item type.
  2. Enter the name lh_learning.
  3. Keep the Lakehouse schemas option enabled. When you create a Lakehouse in the portal, it is enabled by default at the time of writing.
  4. Create the Lakehouse.

Fabric creates the Lakehouse and opens the Lakehouse explorer.

A few notes on the choices:

  • The name. Use lowercase letters, digits and underscores. The name becomes part of OneLake paths, SQL object names and Git folder names, so it is worth keeping simple. The lh_ prefix tells you the item type in any list.
  • Schemas. With schemas enabled, tables are grouped under named schemas, and every schema-enabled Lakehouse has a default dbo schema that cannot be renamed or removed. Tables written without a schema name go to dbo. Several newer Fabric features require a schema-enabled Lakehouse, so keep it on unless you have a specific reason not to.

3. Inspect Files

In the explorer on the left, you see two nodes: Tables and Files. Both are empty.

Create a minimal folder structure in Files. Use the context menu on Files to create subfolders:

Files/
├── landing/
└── raw/
  • landing/ is where files arrive, exactly as the source sent them. Treat it as a drop zone that processes read from and clean up.
  • raw/ keeps an immutable, organized copy of what arrived, often partitioned by date, so you can reprocess history.

You can upload a small file into landing from the explorer if you want to see how files appear. Nothing in the next tutorial depends on it.

4. Inspect Tables

Expand Tables. You see the dbo schema, and it is empty. Tables appear here when something writes a Delta table into the Lakehouse: a notebook, a pipeline copy activity, a Dataflow Gen2 or a load from a file in the Files area.

When you are further along, the Tables area in a learning Lakehouse might look like this:

Tables/
└── dbo/
    ├── bronze_sales
    ├── silver_sales
    └── gold_daily_sales

The prefixes describe each table’s role:

  • bronze_sales: orders as they were received, plus load metadata.
  • silver_sales: cleaned, deduplicated and correctly typed orders.
  • gold_daily_sales: daily revenue, shaped for reporting.

This is the Medallion pattern in its simplest form: one Lakehouse, with table prefixes for the layers. Larger platforms often use separate schemas (bronze.sales) or separate Lakehouses per layer, but for learning, one Lakehouse keeps every step visible. Medallion Architecture Explained covers when each layer earns its place, and the Medallion cheat sheet summarizes it.

5. The SQL analytics endpoint

When you created lh_learning, Fabric also created a SQL analytics endpoint with the same name. You can see it as a separate item in the workspace list, and you can switch between the Lakehouse view and the SQL analytics endpoint view from the Lakehouse explorer.

The SQL analytics endpoint gives you a read-only T-SQL interface over the Lakehouse tables:

  • Analysts query tables with T-SQL from the Fabric query editor, SQL Server Management Studio, Visual Studio Code or any SQL client.
  • You can create views, functions and stored procedures that read Lakehouse tables, and apply object-level security.
  • You cannot insert, update or delete Lakehouse data through it. Writes go through Spark, pipelines or dataflows.

After the next tutorial, this query will work there:

SQL query: 5. The SQL analytics endpointT-SQL (Fabric Warehouse)
SELECT TOP (10) *
FROM dbo.bronze_sales
ORDER BY order_date;
T-SQL (Fabric Warehouse)3 linesRead-only query display. It is not connected to a database.

The endpoint discovers new and changed Delta tables automatically through a metadata sync. It is usually quick, but not instantaneous. If a table you just wrote does not appear yet, refresh the explorer before assuming something is wrong.

6. Where the data lives in OneLake

Nothing about a Lakehouse is a separate database engine with its own storage. Everything is folders in OneLake:

  1. OneLake

    • Tenant lakeOne per organization
  2. Workspace

    • jb-fabric-dev
  3. Lakehouse

    • lh_learning.Lakehouse
  4. Areas

    • Fileslanding/, raw/
    • Tables/dbobronze_sales/, silver_sales/
  5. Readers

    • Spark notebooks
    • SQL analytics endpoint
    • Power BI Direct Lake
A Lakehouse is a folder in the workspace's part of OneLake. Tables are Delta folders under Tables; Files is a plain file system.

Logically, bronze_sales is a table in the dbo schema of lh_learning. Physically, it will be a folder like this:

abfss://jb-fabric-dev@onelake.dfs.fabric.microsoft.com/lh_learning.Lakehouse/Tables/dbo/bronze_sales/
├── _delta_log/
│   └── 00000000000000000000.json
└── part-00000-….snappy.parquet

You can copy the exact ABFS or HTTPS path of any folder or table from its properties in the Lakehouse explorer. Those paths matter when tools outside the workspace, such as a notebook in another workspace or an Azure service, need to reach the data.

Two practical consequences:

  • No copy between engines. Spark writes the files, and the SQL analytics endpoint and Power BI read the same files.
  • Data is not in Git. Git integration stores the Lakehouse definition. Tables and files stay in OneLake, governed by workspace roles and OneLake permissions.

7. Commit the Lakehouse to Git

If you connected the workspace in the previous tutorial, its source control view now shows one pending change.

  1. Open the source control panel and look at the list of changes.
  2. Select lh_learning.
  3. Enter the message Add lh_learning lakehouse and commit.

The repository now contains a folder for lh_learning under fabric/, holding the Lakehouse definition. No data was committed, which is correct.

Why a Lakehouse is useful

  • One copy for many engines. Engineers use Spark, analysts use T-SQL, report authors use Power BI, all on the same Delta tables.
  • Raw and curated data side by side. Keep source files in Files and structured tables in Tables, in one item with one set of permissions.
  • Open format. Delta Lake avoids a proprietary storage format; the data is readable outside Fabric.
  • Scales with Spark. The same Lakehouse works for five rows today and billions later, with partitioning and file-size management as the main tools.
  • A natural home for layered designs. Bronze, Silver and Gold can start as table prefixes and grow into separate schemas or Lakehouses.

Lakehouse vs Warehouse

Fabric has two main stores for analytical tables. Both store Delta tables in OneLake; the difference is the engine you write with.

Lakehouse Warehouse
Write engine Spark (PySpark, Spark SQL), pipelines, dataflows T-SQL
T-SQL Read-only through the SQL analytics endpoint Full DML: INSERT, UPDATE, DELETE, MERGE
Unstructured files Yes, in Files No
Multi-table transactions No Yes
Typical team Data engineers comfortable with Python and Spark SQL developers and BI engineers

Neither one is the “better” choice. Many platforms ingest and transform in a Lakehouse and serve some data through a Warehouse. Microsoft Fabric Lakehouse vs Warehouse covers the decision in depth, and the Lakehouse vs Warehouse cheat sheet is the one-page version.

When I would choose a Lakehouse

  • Raw files are part of the job. CSV drops, JSON from APIs, Parquet exports: they belong in Files before they become tables.
  • The transformations need code. Parsing, deduplication, complex joins and MERGE logic are often more natural in PySpark than in T-SQL.
  • The team is engineering-led. People who already write Python or Spark will be productive immediately.
  • Data volumes will grow. Spark’s distributed processing gives you room before you need to redesign.
  • It is the landing and transformation layer of a layered design, even if a Warehouse serves the final model.

I would lean towards a Warehouse when the team is mostly T-SQL developers, when the logic depends on multi-table transactions, or when the workload is a classic dimensional model maintained with stored procedures.

Common mistakes

  • Putting CSV files under Tables. Tables expects Delta. Land files in Files and load them into tables.
  • Treating the SQL analytics endpoint as writable. It is read-only for Lakehouse data. Writes go through Spark, pipelines or dataflows.
  • Names with spaces or uppercase. They work in places, then cause quoting problems in Spark, SQL and paths. Use lowercase with underscores.
  • One Lakehouse for everything, forever. Fine for learning. In production, split by domain or layer when permissions, ownership or lifecycle differ.
  • Disabling schemas without a reason. You lose organization options and some newer features, and converting later is not trivial.
  • Expecting Git to contain the data. Git stores the Lakehouse definition only.

What you learned

  • A Lakehouse combines a file area and a table area over OneLake, with Spark as its write engine.
  • Files is an unmanaged file system for raw data; Tables holds managed Delta tables, grouped in schemas with dbo as the default.
  • Delta Lake turns Parquet files plus a transaction log into tables with ACID writes and history.
  • Every Lakehouse gets a read-only SQL analytics endpoint for T-SQL queries over its tables.
  • Physically, lh_learning is a folder in the workspace’s part of OneLake, and each table is a Delta folder under Tables/dbo/.
  • You created lh_learning, prepared Files/landing and Files/raw, and committed the Lakehouse definition to Git.

Next: Create Your First Fabric Notebook

The Lakehouse is ready and empty. Next, create a notebook attached to lh_learning, build a small dataset with PySpark, and write it as your first Delta table, bronze_sales: Create Your First Fabric Notebook.

Previous step: Connect Microsoft Fabric to Git. Full sequence: Microsoft Fabric learning path.

Tags

  • Microsoft Fabric
  • Fabric Lakehouse
  • SQL Endpoint
  • Delta Lake