Explore the Databricks Workspace UI

Imagine you've just been handed the keys to a Databricks workspace, but the moment you log in, you're staring at a screen full of unfamiliar menus, icons, and panes. The sidebar alone can feel like a maze, and you're not sure whether to click Create, SQL, or Workflows — you just need to run some code. Without a solid mental map of the Databricks workspace UI, you'll waste time hunting for buttons, misplace notebooks, or even run code against the wrong compute. That's exactly the pain this lesson solves: by the end, you'll navigate the workspace like you've been using it for months.

The problem this lesson solves

When you first open a Databricks workspace, the sheer number of features — notebooks, clusters, jobs, SQL warehouses, lakehouse objects, and data catalogs — can feel overwhelming. New users often get lost clicking through the sidebar and end up creating resources in the wrong place, or they struggle to find the notebooks their teammates have shared. The challenge is even worse when you're under pressure to deliver a quick data analysis: every minute spent searching for a button is a minute not spent on your actual work.

Pro tip: Most Databricks workspace actions are one or two clicks away. The key is knowing which icon to click first — the sidebar is your compass.

This lesson gives you a structured tour of the Databricks workspace UI, so you can quickly locate the tools you need. You'll learn what each core area does, how notebooks and clusters fit together, and how to avoid common pitfalls like running code without a cluster or saving work to the wrong folder.

Core concept / mental model

Think of the Databricks workspace as a control center for your data engineering tasks. It's not just a place to write code — it's a orchestration hub where you manage:

• Notebooks — your primary coding environment for Python, SQL, Scala, or R
• Clusters — the compute engines that actually run your code
• Jobs — scheduled or triggered workflows that automate your pipelines
• Data objects — tables, views, and files stored in the lakehouse
• Repos — Git integration for version control and CI/CD

A useful mental model is the kitchen analogy: the workspace sidebar is your pantry (organized shelves with labels), notebooks are your recipe cards, and clusters are the ovens — you need to turn on an oven before you can bake. Similarly, you must attach a running cluster to a notebook before executing cells.

What is the Databricks workspace UI?

To be precise, the Databricks workspace UI is the web-based interface that lets you interact with all the platform's features. It's built around a left sidebar that changes context based on the section you choose. The main areas you'll interact with in this lesson are:

• Home — your landing page with recent notebooks, queries, and files
• Workspace — a file explorer for organizing notebooks, libraries, and dashboards
• Compute — for creating and managing clusters and SQL warehouses
• Workflows — for building and monitoring data pipelines
• Data — to browse tables, volumes, and the catalog explorer
• Repos — for connecting to GitHub, GitLab, or Bitbucket

Each sidebar item opens a dedicated view, but the global top bar stays visible, giving you search, user settings, and the ability to create new resources.

How it works step by step

Follow this logical path to become comfortable with the workspace UI:

1. Sign in to your Databricks workspace — The URL usually looks like https://<workspace-url>.cloud.databricks.com/. After you log in, you land on the Home page.

2. Create a notebook — Click the + New button (top right) and select Notebook. Name it, pick a language (Python is fine for now), and choose a cluster (or select 'Create a new cluster' to set one up in a moment).

3. Create or select a cluster — From the sidebar, click Compute, then Create a new cluster. Give it a name, leave the default runtime, and press Create Cluster. A cluster takes a minute to start — you'll see its status change from Pending to Running.

4. Run your first cell — Back in your notebook, attach the cluster via the dropdown in the top toolbar. Type a simple command like print('Hello, Lakehouse!') and press Shift+Enter to run it. The output appears immediately below the cell.

5. Save and organize — Your notebook is saved automatically, but you can move it into a folder in the Workspace section. Right-click the notebook in the left file tree and choose Move to drag it into a shared folder.

6. Explore the Data tab — Click Data to see Catalog, mounted data sources, and tables. You'll use this later when querying data.

Why this order matters

The sequence above is deliberate: you create the compute before you run code, and you understand where things live before you start building complex pipelines. This foundation prevents the classic mistake of running a notebook that's attached to no cluster, which results in an immediate error.

Hands-on walkthrough

Let's solidify your understanding with a short, practical exercise. We'll create a notebook, attach it to a cluster, and run a small Python script to confirm everything works.

Step 1: Create a new notebook

1. In the top-left corner, click the + New button.
2. Choose Notebook from the dropdown.
3. In the dialog, give your notebook the name MyFirstNotebook.
4. Ensure Python is selected as the default language.
5. Leave the cluster field set to Create a new cluster, and click Create.

The notebook opens in the main editing area, and a new cluster starts up in the background.

Step 2: Configure a simple Python script

In the first cell, paste the following code:

# my_first_notebook.py
# This cell prints a message and shows the current Spark version
from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("WorkspaceUILesson").getOrCreate()

print("Hello from the Databricks workspace!")
print(f"Using Spark version: {spark.version}")

When you run this cell (click the Run cell button or press Shift+Enter), you should see output similar to:

Hello from the Databricks workspace!
Using Spark version: 3.5.0

Step 3: Create a DataFrame and display it

Now add a second cell with the code below to create a tiny DataFrame and render it in the notebook's native tabular view:

# Create a simple DataFrame
data = [("Alice", 34), ("Bob", 45)]
df = spark.createDataFrame(data, ["name", "age"])
display(df)

After running this cell, you'll see a properly formatted table with columns name and age under the cell — not a raw text dump. That's the UI's display() function at work, a huge quality-of-life upgrade over plain show().

Blockquote pro tip: Use display() instead of show() in notebooks to get interactive visualizations and easier data exploration. It's built into Databricks and you'll use it constantly.

Step 4: Use the sidebar to jump around

While your notebook is still open, click Workspace in the sidebar. You'll see your notebook listed in the shared file tree. Then click Compute to see your running cluster's status. Finally, return to your notebook using the breadcrumb at the top of the page. You've just exercised the core navigation pattern of the UI.

Compare options / when to choose what

The Databricks workspace UI isn't your only way to interact with the platform — you also have the CLI, REST API, and Terraform. Here's a quick comparison to help you decide when to use each:

For this lesson, and for most day-to-day data engineering tasks, the workspace UI is your go-to. You'll likely shift to the CLI or API as you build production pipelines, but learning the UI first gives you the mental model needed to understand what those tools do under the hood.

Troubleshooting & edge cases

Even in the friendly UI, you'll hit confusing moments. Here are the most common issues and how to fix them:

Error: "Cluster is not started, could not attach"

• Cause: You tried to run a notebook cell before the cluster finished provisioning.
• Fix: Wait for the cluster status to show Running in the Compute tab. Then re-run the cell.

Error: "No active cluster found"

• Cause: The notebook isn't attached to any cluster (or the cluster was terminated).
• Fix: Use the cluster dropdown in the notebook toolbar to select a running cluster, or click Create new to spin one up.

Problem: My colleague can't see my notebook

• Cause: You saved it in your personal home folder instead of a shared workspace folder.
• Fix: Move the notebook to a shared folder (e.g., /Users/team/...) via the Workspace file browser, and ensure the folder permissions allow access.

Issue: The sidebar is missing

• Cause: You may have accidentally collapsed it.
• Fix: Click the hamburger icon at the top left of the workspace to expand the sidebar again.

Edge case: Multiple clusters with similar names

• Problem: You attach the wrong cluster and run heavy jobs on a tiny node.
• Solution: Adopt a clear naming convention (e.g., etl-prod, etl-dev) and always verify the selected cluster's name in the notebook dropdown before running.

What you learned & what's next

Excellent work! You've completed your tour of the Databricks workspace UI. Let's recap what you accomplished:

• You understand the problem that the workspace UI solves — organizing the many resources of the Databricks platform.
• You built a mental model of your workspace as a control center, with the sidebar as your navigation compass.
• You completed a hands-on exercise that involved creating a notebook, attaching it to a cluster, and running Python + Spark code.
• You learned to compare the UI with other interfaces like the CLI and API, and you know how to troubleshoot the most common navigation and compute issues.

You've met the lesson's learning objectives: you can explain the core idea behind the Databricks workspace UI and complete practical exercises using it.

Now you're ready to dive deeper into the Databricks toolkit. The natural next step is to learn how to create and configure clusters — understanding instance types, autoscaling, and policies — so you can run your notebooks efficiently in production scenarios. Master that, and you'll be well on your way to building real data pipelines in the lakehouse.