What types of applications are not a good fit for serverless?

Summary

• Databricks serverless compute runs most Python and SQL workloads, but some workload types still require classic compute — the Databricks documentation frames these as cases where you should "use dedicated compute instead."
• Language and runtime needs: workloads that depend on Scala or R, that need Databricks Runtime for ML, or that require GPU-accelerated compute are a better fit for classic compute.
• Task types and APIs: JAR tasks, Spark Submit jobs, and workloads built on the RDD API are not supported on serverless and run on classic jobs compute.
• Deep customization: custom containers (Databricks Container Service), cluster-scoped init scripts and libraries, custom Spark configurations or engine extensions, and custom (for example JDBC-based) data sources point you to classic compute.
• Networking, region, and metastore constraints: workloads that need private networking serverless does not support, run in a region without serverless, or still use the legacy Hive metastore should use classic compute. Support continues to expand, so check the current Databricks documentation.

What types of applications are not a good fit for serverless?

Databricks serverless compute is designed to run most Python and SQL workloads with automatic provisioning and no infrastructure to manage. Some workload types, however, depend on capabilities serverless does not currently provide, and the Databricks documentation recommends running those on classic (dedicated) compute. The categories below summarize where classic compute is the appropriate choice. Because serverless capabilities continue to expand, always confirm the current limitations in the Databricks documentation before deciding.

Workloads better suited to classic compute

• Workloads that need unsupported languages or runtimes. Scala and R are not supported on serverless compute, so notebooks and jobs that depend on them require classic compute. Databricks Runtime for ML is also not available on serverless (you install ML libraries individually as compute-scoped libraries instead), and GPU-enabled compute is not supported — so GPU-accelerated and ML-runtime workloads are a better fit for classic compute.
• Workloads using unsupported task types or APIs. JAR tasks and Spark Submit jobs are not supported on serverless and run on classic jobs compute, and workloads built on the RDD API are not supported on serverless.
• Workloads that require deep customization. Custom containers and Databricks Container Service are not supported; cluster-scoped init scripts and libraries cannot be used (Environments are the serverless alternative); custom Spark configurations have limited support and Spark engine extensions are not allowed; and custom data sources such as JDBC-based connectors are not supported, though Lakehouse Federation sources are.
• Workloads with specific storage assumptions. Serverless does not support FUSE for DBFS root and mounts, and clients such as dbutils can only read from cloud storage using external locations rather than DBFS mounts, so workloads that rely on those patterns fit classic compute better.
• Workloads with networking, region, or metastore constraints. Use classic compute when a workload requires private networking that serverless does not support, runs in a region where serverless is not available, or still uses tables in the legacy Hive metastore instead of Unity Catalog.

Choosing between serverless and classic compute on Databricks

Serverless compute is a strong default for interactive notebooks, jobs, and pipelines that use Python or SQL, because it starts quickly and is fully managed. Classic compute remains the right choice when a workload needs one of the capabilities above. Databricks provides guidance for matching each task to the recommended compute type, and serverless support continues to broaden over time, so a workload that needs classic compute today may become serverless-eligible later — reviewing the current documentation is the best way to decide.

Getting started

• Read Migrate from classic compute to serverless compute for the current list of what is and is not supported.
• Review Serverless compute limitations.
• See Recommended compute for each task and Compute selection recommendations.

FAQs

Can I run Scala or R jobs on serverless compute?

No. Scala and R are not supported on serverless compute, so notebooks and jobs that depend on them should run on classic compute.

Are JAR tasks and Spark Submit jobs supported on serverless?

No. JAR tasks and Spark Submit jobs are not supported on serverless and run on classic jobs compute; workloads built on the RDD API are also unsupported on serverless.

When should I use classic compute instead of serverless?

Use classic compute for workloads that need Scala or R, Databricks Runtime for ML or GPUs, JAR/Spark-Submit tasks, custom containers, init scripts, or Spark engine extensions, or that have private-networking, region, or legacy Hive metastore requirements.