Databricks Asset Bundles are now called Declarative Automation Bundles in current Databricks documentation. For Data Engineer Associate, the engineering boundary is source-controlled declaration, validation, promotion, identity, drift, and rollback rather than the product-name history itself. The 2026 rename is non-breaking: existing databricks bundle commands and configuration do not need to be rewritten solely because of the new name. Within Databricks Data Engineering, Declarative Automation Bundles are the deployment boundary for source code plus jobs, pipelines, dashboards, apps, model-serving resources, vector-search resources, and other supported Databricks objects that need repeatable promotion across environments.
A bundle is the source-controlled definition of a Databricks workload
A bundle is more than a folder of notebooks. It contains source files, metadata, resource definitions, deployment targets, and project structure needed to test and deploy the workload.
The root databricks.yml file defines the bundle and can include other configuration files. Resources can be split into separate YAML files so jobs, pipelines, and other objects remain readable as the project grows.
This turns the repository into a reproducible description of the Databricks workload rather than a loose code archive beside manually configured workspace resources.
Bundles are successful when another engineer can reproduce the release. A mature project lets a new engineer inspect the repository and understand what will be deployed, which target it uses, which resources are created, how validation works, who deploys it, and how rollback is performed.
That is a stronger operational handoff than instructions such as “open the workspace and recreate these settings.” Declarative Automation Bundles bring software-engineering discipline to Databricks resources because the resource definition, source code, and deployment behavior can be reviewed together.
Targets should promote one source revision across environments
Bundle targets can represent development, staging, production, or other environments. A target can alter workspace destination, permissions, variables, resource names, and other settings without duplicating the entire project.
Environment differences should remain deliberate. If production requires a different catalog, service principal, or policy identifier, put that difference in configuration. If the transformation code itself diverges heavily, the team should ask whether the environments are really one product anymore.
Targets are strongest when they reduce drift rather than create a second layer of conditional logic. Environment promotion should reuse the same source revision. Rebuilding production from a newer local checkout than the version validated in staging weakens the purpose of the pipeline. CI should promote an immutable commit or artifact so testing evidence follows the exact release.
Validation, plans, and smoke tests protect releases
The Databricks CLI can validate a bundle before deployment. Validation checks the project configuration and supported schema so obvious errors are caught before resources are changed in a workspace.
Validation should be part of CI, but it is not sufficient on its own. A valid bundle can still reference data, secrets, catalogs, policies, or permissions that do not exist or are not authorized in the target environment.
Preproduction deployment tests should therefore combine bundle validation with real runtime checks. Plan output is valuable before production changes because it shows which resources the deployment intends to add, update, or remove. Reviewers can catch a surprising deletion or recreation before it reaches the workspace. This is especially important for jobs with schedules, permissions, and run history that operators depend on.
Bundle-based development should include test data and smoke tests that run after deployment. Configuration validation proves the resource definition is syntactically valid; a smoke test proves the deployed job can access its catalog, secrets, libraries, and source data under the real runtime identity.
The direct deployment engine is now the current default for new bundles. Current bundle release notes show that Databricks made the direct deployment engine generally available in June 2026 and uses it by default for new bundles created with Databricks CLI 1.3.0 and above, replacing the older Terraform-based deployment engine for those projects.
New bundles created with Databricks CLI 1.3.0 and later default to direct deployment. Starting with CLI 1.14.0, Terraform-engine bundles are automatically migrated to the direct engine on deploy. A Terraform opt-out could still be used through CLI 1.19, but CLI 1.20 and later reject that setting rather than continuing with the old engine. Migration deserves a reviewed bundle plan and pinned CLI version: unlike the Terraform engine, the direct engine resets removed configuration fields to the platform defaults on the next deployment. That difference can change a production resource even when the team believes it only removed a redundant setting.
Resource identity is one of the most important details in a declarative deployment. A job or pipeline that is renamed in source can sometimes be interpreted as a new resource unless the deployment state preserves the relationship correctly. Renames and deletions should therefore be reviewed as lifecycle changes rather than treated as harmless wording edits.
Supported resources expand the review blast radius
Supported bundle resources continue to expand. Current documentation includes jobs, pipelines, dashboards, apps, model-serving endpoints, databases, Genie agents, vector-search endpoints and indexes, and additional Databricks resources.
This makes bundles useful as a common deployment surface across data engineering and AI, but it also increases the blast radius of a poorly reviewed change.
Repositories should be organized so reviewers can see which resource types a pull request affects. The most important benefit of bundles is organizational: code review can include platform resources. A pull request can show not only the notebook diff but also the schedule, permissions, compute mode, tags, and dependencies that will change. That shared review surface is what turns workspace configuration into software engineering.
Templates and repository boundaries encode platform standards
Databricks supports default and custom bundle templates. Templates can establish folder structure, build steps, tests, deployment metadata, and other common practices when new projects are created. A platform team can use templates to make good defaults easy—naming, tags, permissions, CI structure, tests—without forcing all workloads into one shared repository.
Templates should remain opinionated enough to reduce drift but flexible enough for projects with genuinely different runtime needs. Bundle templates can also encode observability defaults. New jobs can start with standard tags, timeout conventions, notifications, ownership metadata, and naming rules rather than adding them later after incidents. The template becomes a platform product when it captures these repeated engineering decisions.
Large repositories should avoid one giant bundle for unrelated data products. Shared code libraries can remain shared, but deployments are easier to reason about when each bundle has a coherent owner, release cadence, and blast radius. A platform-wide monolithic bundle can turn one small pipeline change into a release touching dozens of unrelated resources.
Selective deployment is a development tool, not the production release model
Current bundle tooling includes bundle plan and bundle deploy options that can select individual resources for targeted development workflows. Databricks documentation explicitly notes that selective deployment is not intended as the normal production pattern.
That guidance reflects a broader release principle: production should move as a coherent reviewed state rather than by manually cherry-picking one resource because it is convenient during an incident.
Targeted tools are useful for iteration, not as a substitute for a reproducible production deployment.
Deployment identity, runtime identity, secrets, and permissions must stay distinct
CI/CD should deploy with service principals or other durable workload identities rather than a developer’s personal account. The deployment identity needs enough permission to create or update the declared resources, but it should not become an unnecessary workspace administrator.
Data permissions remain separate. A job can be deployed successfully and still fail at runtime because its execution identity lacks Unity Catalog privileges.
The repository should make deployment identity and runtime identity distinct where the security model requires it. Secrets should not be committed into bundle configuration. Targets can reference secret scopes, service principals, workspace resources, or external configuration without embedding credentials directly in YAML. Repository scanning and CI policy should enforce that boundary.
Permissions should be reviewed as code whenever they are declared in the bundle. A deployment that grants a broader workspace or resource role can be more consequential than a notebook code change. Reviewers should therefore treat access-control diffs as security changes, not as routine metadata.
Source-controlled state prevents manual drift
A bundle-managed production resource should not also be edited routinely by hand in the workspace. Manual changes can be overwritten by the next deployment or can create confusing differences between source and production state. Emergency edits should be reconciled back into source before the next release. The same applies to renames or deletions, which may have lifecycle consequences beyond a normal configuration update. The value of declarative deployment comes from having one trusted description of the intended state.
Rollback and ownership need a durable change record
Rollback should be designed as an actual release action. Source control can restore the previous configuration, but the team should know whether reverting code also needs to restore data schema, job parameters, or external resources. Declarative infrastructure improves rollback only when stateful dependencies are understood.
Bundle metadata should also identify ownership and support contacts. When a production job fails months later, operators should be able to find the repository and team from the deployed resource without searching organizational memory.
Workspace collaboration features can accelerate iteration, but production should still preserve source control as the durable change record. Editing a bundle in the workspace is useful during development as long as the resulting source changes are committed and reviewed before promotion.