Is Databricks serverless cheaper than classic compute?

Sometimes. On AWS in US East, Premium tier, serverless jobs cost $0.35 a DBU with the machines included, while classic jobs compute costs $0.15 a DBU plus the EC2 bill. Serverless wins when it uses few enough DBUs, when clusters would otherwise sit idle or wait to start, and in standard performance mode, which Databricks says can cost up to 70% less than performance-optimized mode. Measure one run in system.billing.usage before moving a large job.

What is the difference between Databricks serverless and classic compute?

Classic compute runs on virtual machines in your own cloud account: you choose the instance type, workers, runtime version and Spark settings, and pay the cloud for the machines and Databricks for DBUs. Serverless runs in Databricks' account: Databricks picks and scales the machines, keeps the runtime up to date, turns on Photon and autoscaling, and bills only DBUs.

What does Databricks serverless not support?

R, Spark RDD APIs, init scripts, compute-scoped libraries, instance pools, compute policies, Databricks Container Services, Maven coordinates, global temp views, df.cache() and other cache APIs, Hive SerDe tables, the Spark UI and Spark logs, most Spark configurations, and the ProcessingTime and Continuous streaming triggers. Runs end after 7 days. It also needs Unity Catalog.

What is standard performance mode on Databricks serverless?

A setting for serverless jobs and Lakeflow pipelines that uses less compute and starts in 4 to 6 minutes. It is billed under the same SKU but uses fewer DBUs; Databricks says it can cost up to 70% less than performance-optimized mode. It is not available for notebooks.

How do I see what a serverless job costs?

Query the system.billing.usage system table, filtering on usage_metadata.job_id, and multiply the DBUs by the list price. Charges can take up to 24 hours to appear in the table.

Databricks serverless vs classic compute: cost, limits and when to switch

Serverless compute on Databricks costs more per DBU than classic jobs compute but includes the machines, starts in seconds and stops when the work does. When it is cheaper, what it cannot run (R, RDDs, init scripts, cache(), time-based streaming triggers), and a worked break-even for a nightly job.

Tecyfy · Published 26 October 2026 · 8 min read

A taxi marked Serverless waiting at the kerb beside a garage where a car sits with its bonnet open

Databricks serverless compute costs more per DBU than classic jobs compute, but the price includes the machines, so whether it is cheaper depends on how many DBUs your job uses. On AWS in US East, Premium tier, serverless jobs cost $0.35 a DBU all in; classic jobs compute costs $0.15 a DBU plus the EC2 bill for every node.

Serverless also removes the work around clusters: no instance types, no runtime upgrades, no waiting for machines. In exchange it will not run some code that classic compute runs. Here is how to decide, job by job.

What changes when you switch

	Classic compute	Serverless
Where it runs	Machines in your cloud account	Machines in Databricks' account
Bill	DBUs to Databricks + machines to the cloud	DBUs only
AWS, Premium, US East, jobs	$0.15 a DBU + EC2	$0.35 a DBU
AWS, Premium, US East, notebooks	$0.55 a DBU (all-purpose) + EC2	$0.75 a DBU
You choose	Instance type, workers, runtime, Spark settings	Performance mode and environment version
Photon and autoscaling	Your choice	Always on
Start-up	Minutes while machines boot	Fast from warm compute (performance-optimized) or 4 to 6 minutes (standard)
Runtime upgrades	You pick and upgrade	Automatic, always the latest

The rates are Databricks' list prices as we read them on 20 October 2026; they differ by region and cloud. The Databricks cost calculator has every region.

What serverless cannot run

Check your job against this list before anything else. Serverless needs Unity Catalog, and it does not support:

R, and Spark RDD APIs (only Spark Connect APIs). Scala and R do not run in serverless notebooks; JAR tasks do run in jobs.
Init scripts, compute-scoped libraries, instance pools, compute policies and Databricks Container Services. Libraries go in a serverless environment instead.
df.cache(), persist(), CACHE TABLE and the other cache APIs: they raise an error.
Streaming triggers other than AvailableNow and Once. A stream with no trigger set defaults to ProcessingTime, so it fails until you set one; continuous streams belong in a serverless Lakeflow pipeline.
Most Spark settings. Only a listed few, set in the session.
The Spark UI and Spark logs. Use the query profile.
Runs longer than 7 days, Maven coordinates, global temp views, Hive SerDe tables and VPC peering.

Two behaviours also change quietly: ANSI mode is on, so a bad cast raises an error instead of returning NULL, and the session time zone is UTC. Run the job once on serverless before trusting its output.

A worked break-even

A nightly job runs for 1 hour on a classic jobs cluster: 1 driver and 4 workers of m6id.2xlarge (8 vCPUs, 32 GiB), without Photon, 30 runs a month.

Each node costs 1.52 DBUs × $0.15 + $0.4746 for the machine = $0.7026 an hour.
5 nodes for 1 hour: $3.51 a run, $105 a month.
Serverless at $0.35 a DBU is cheaper only if a run uses fewer than $3.51 ÷ $0.35 = 10.0 DBUs.

Serverless always runs Photon, so compare it with a classic cluster with Photon on too: 4.408 DBUs × $0.15 + $0.4746 = $1.1358 a node-hour, $5.68 a run, and the break-even rises to 16.2 DBUs.

Say a test run on serverless shows 12 DBUs in system.billing.usage. That is $4.20 a run, $126 a month: a little more than the plain classic cluster, less than the Photon one. If the job can wait 4 to 6 minutes to start, standard performance mode uses fewer DBUs under the same price; Databricks says up to 70% less.

Try itOne job, on a classic cluster or serverless

Workers (m6id.2xlarge)

Minutes per run

60 min

Runs a month

Serverless DBUs per run

On classic compute each run costs $3.51, $105 a month. Serverless at 12 DBUs a run costs $4.20, $126 a month. Serverless is cheaper while a run uses fewer than 10.0 DBUs.

AWS US East (N. Virginia), Premium tier: classic jobs compute $0.15 a DBU plus EC2 on demand ($0.4746 an hour for m6id.2xlarge, 1.52 DBUs an hour, 4.408 with Photon); serverless jobs $0.35 a DBU, machines included. Classic counts 1 driver plus the workers, from start to finish of the run; cluster start-up time is left out of both.

Where serverless usually wins

Idle clusters. A classic all-purpose cluster bills until its auto-termination period passes after the last command. A team that leaves notebooks attached pays for the gaps.
Short, frequent jobs. A 5-minute job on classic compute also waits for machines to boot; performance-optimized serverless draws on warm compute Databricks keeps ready.
Spiky work. Serverless scales for each run without anyone sizing a cluster.
Teams without a platform engineer. No runtime upgrades, no instance choices, no cluster permissions to hand out.

Where classic usually wins

Long, steady jobs that keep a well-sized cluster busy, especially on spot or reserved machines your cloud discounts.
Code serverless will not run: R, RDDs, init scripts, custom containers, cache(), continuous streaming in a job.
Tuning you rely on: Spark settings, instance families, the Spark UI.

What to do

Find your largest jobs in system.billing.usage; our guide to a Databricks bill that is too high has the queries.
Check each against the limits above.
Run one copy on serverless and read its DBUs (they can take up to 24 hours to appear).
Compare with the break-even from the widget, and try standard performance mode for anything scheduled.
Move jobs that win; keep the rest on right-sized classic clusters. The Spark cluster calculator helps size those.

Questions

Is Databricks serverless cheaper than classic compute?: Sometimes. On AWS in US East, Premium tier, serverless jobs cost $0.35 a DBU with the machines included, while classic jobs compute costs $0.15 a DBU plus the EC2 bill. Serverless wins when it uses few enough DBUs, when clusters would otherwise sit idle or wait to start, and in standard performance mode, which Databricks says can cost up to 70% less than performance-optimized mode. Measure one run in system.billing.usage before moving a large job.
What is the difference between Databricks serverless and classic compute?: Classic compute runs on virtual machines in your own cloud account: you choose the instance type, workers, runtime version and Spark settings, and pay the cloud for the machines and Databricks for DBUs. Serverless runs in Databricks' account: Databricks picks and scales the machines, keeps the runtime up to date, turns on Photon and autoscaling, and bills only DBUs.
What does Databricks serverless not support?: R, Spark RDD APIs, init scripts, compute-scoped libraries, instance pools, compute policies, Databricks Container Services, Maven coordinates, global temp views, df.cache() and other cache APIs, Hive SerDe tables, the Spark UI and Spark logs, most Spark configurations, and the ProcessingTime and Continuous streaming triggers. Runs end after 7 days. It also needs Unity Catalog.
What is standard performance mode on Databricks serverless?: A setting for serverless jobs and Lakeflow pipelines that uses less compute and starts in 4 to 6 minutes. It is billed under the same SKU but uses fewer DBUs; Databricks says it can cost up to 70% less than performance-optimized mode. It is not available for notebooks.
How do I see what a serverless job costs?: Query the system.billing.usage system table, filtering on usage_metadata.job_id, and multiply the DBUs by the list price. Charges can take up to 24 hours to appear in the table.

Sources