Asset Bundles

Global job parameters

Global job parameters were always my dream. Additionally, centralized config for DABs. It is now possible thanks to Mutators! #databricks [https://databrickster.medium.com/global-job-parameters-thanks-to-dabs-mutators-2ad0d94bda1c](https://databrickster.medium.com/global-job-parameters-thanks-to-dabs-mutators-2ad0d94bda1c) [https://www.sunnydata.ai/blog/declarative-automation-bundles-mutators-job-parameters](https://www.sunnydata.ai/blog/declarative-automation-bundles-mutators-job-parameters)

Managing Default Start State for Continuous Streaming Jobs in Databricks Asset Bundles

Databricks Connect v2.10.7 wants admin permissions on local machine

Anyone experienced this already? When I (auto)updated databricks connect plugin in VSCode today I needed to create a new Auth profile. I was taken to a new login screen where I needed to give Databricks admin permissions (which I can't give on company resources). Anyone experienced this / has way around it? Somehow it mostly seems to affect the Databricks connect plugin as my CLI seems to work,but this doesn't bode well for the (near) future. (edited company info out) https://preview.redd.it/m27ignwc232h1.png?width=434&format=png&auto=webp&s=f05168a6c95cdba6b753628ad15256245d129ddc # packages/databricks-vscode # (2026-05-07) * Add remote mode for initial Remote Development compatibility (#1861) ([9e768db](https://github.com/databricks/databricks-vscode/commit/9e768db)) * Rename "Databricks Asset Bundles" → "Declarative Automation Bundles" (#1864) ([62a94e1](https://github.com/databricks/databricks-vscode/commit/62a94e1)) * Preserve profile name in Databricks CLI auth provider (#1877) ([3f54441](https://github.com/databricks/databricks-vscode/commit/3f54441)) * Fix new profile sign in using already existing host under different profile (#1893) ([c4c25fb](https://github.com/databricks/databricks-vscode/commit/c4c25fb)) * Include profiles with `account_id` in `listProfiles` results (#1894) ([d6e2e5d](https://github.com/databricks/databricks-vscode/commit/d6e2e5d)) * Update minimal python and dbconnect versions for serverless (#1884) ([5a1a1d5](https://github.com/databricks/databricks-vscode/commit/5a1a1d5)) * Update Databricks CLI to v0.297.2 (#1882) ([ea77424](https://github.com/databricks/databricks-vscode/commit/ea77424)) — see the [CLI release notes](https://github.com/databricks/cli/releases) for changes since v0.286.0

Tagging Catalogs and Schemas using DABs

Do DABs support Catalog/Schema tagging? I need this functionality to trigger GitHub CODEOWNER reviews on the basis of the tags... (InfoSec is looped in for restricted data classification grants)

DABs templates

DABs templates

We can configure a folder in Workspace for custom DABs templates. If we click Create Bundle in the git repo, we can use our ready DABs template. #databricks [https://databrickster.medium.com/databricks-news-lakeflow-designer-uv-package-manager-genie-tasks-disable-lakeflow-tasks-3e2cfb9ef86b](https://databrickster.medium.com/databricks-news-lakeflow-designer-uv-package-manager-genie-tasks-disable-lakeflow-tasks-3e2cfb9ef86b)

Catalog Workspace Bindings GA timeline in DABs?

As per title. Would appreciate any insights on this from the Databricks Team. I need this capability for cross BU Data sharing.

Development loop for DABs

I've been learning a bit about DABs. My end goal is to develop a template, a how-to guide for our org, and then get some analysts using DABs to make deploying their projects easier, faster, and more flexible. After that is working, deploy from sandbox to dev to prod using Azure Devops CI/CD. I am experimenting with the delivered templates - so I'll start there. If I choose the sql project, I get two sql files that have embedded templating language with variables and an if statement. How are you supposed to debug this code or develop new code? Is the debug loop 'change code -> deploy -> run job -> look at output -> change code'? Seems like it will add a lot of time waiting for jobs to spin up, looking at output, lacking genie code fixes (I induced an error and it wants to fix the .bundle files). 95% of our time is spent developing, analyzing - help me understand how this fits in with that work, because if this is the way foward I feel like I'm missing something! -- This query is executed using Databricks Jobs (see resources/default_sql_sql.job.yml) USE CATALOG {{catalog}}; USE IDENTIFIER({{schema}}); CREATE OR REPLACE MATERIALIZED VIEW orders_daily AS SELECT order_date, count(*) AS number_of_orders FROM orders_raw WHERE if( {{bundle_target}} = "prod", true, -- During development, only process a smaller range of data order_date >= '2019-08-01' AND order_date < '2019-09-01' ) GROUP BY order_date

Managing Unity Catalog Permissions for Databricks Apps via DABs

DABs serving endpoint

Hey, how do people use the serving\_endpoint resource in Databricks Asset Bundles? For example, i have a model\_training job that produces a new model version, which kicks off a model\_deployment job that validates the new version against the current \`@Champion\`. If validation passes, we promote the alias and gradually roll out traffic on the real-time endpoint, ramping to 100% if it stays healthy. For the gradual rollout, the deployment job calls \`update\_endpoint\` via the Python SDK to shift traffic between served\_entities. The moment that runs, the endpoint drifts from whatever \`entity\_version\` is pinned in the YAML — and any future \`bundle deploy\` would revert serving back to the old version. So what is the point of the serving\_endpoint resource in DABs if i need to update it via SDK anyway?

AI/BI Dashboard refresh via DABs + Jobs executes successfully but dashboard does not update without

Databricks Data Engineer Associate Exam Updated for 2026

The Databricks Data Engineer Associate exam changed on May 4, 2026. The exam now has 7 domains instead of 5. Two new domains were added. The first new domain is CI/CD. This includes: • Databricks Repos • Git integration • Branching and commits • Deploying Declarative Automation Bundles • Using the Databricks CLI • Moving code from dev to test to production Databricks Asset Bundles is now called Declarative Automation Bundles, so learn the new name. If you have never used Git or the Databricks CLI inside Databricks, spend some time practicing in the Free Edition. Connect a Git repo, make commits, and deploy bundles. Hands-on practice will help a lot. The second new domain is Troubleshooting, Monitoring, and Optimization. This includes: • Reading the Spark UI • Finding bottlenecks like data skew and excessive shuffling • Understanding Liquid Clustering • Predictive optimization • Troubleshooting cluster and memory issues Many courses do not teach Spark UI deeply, so try running queries yourself and checking the Spark UI. Compare good queries with inefficient ones to understand the difference. Some existing domains also changed. Ingestion now includes Lakeflow Connect along with Auto Loader and COPY INTO. Governance now includes: • Column-level masking • Row-level security • Attribute-based access control You now need to understand security beyond basic GRANT permissions. Lakeflow Jobs also tests three trigger types: • Scheduled • File arrival • Table update Know when to use each one. Some product names also changed: • Databricks Asset Bundles → Declarative Automation Bundles • Delta Live Tables → Lakeflow Declarative Pipelines The exam uses the new terminology, so update your study material if you are using older resources. The exam format is still: • 45 scored questions • 90 minutes • $200 There may also be extra unscored questions mixed into the exam. For preparation, the original Academy courses still help for the old domains. But for the two new domains, hands-on practice is very important. Practice: • Spark UI • Git integration • Databricks CLI • Deployments using bundles Also read the latest official exam guide PDF from the Databricks page. Good luck to everyone preparing for the exam.

Vector Search in DABS

More and more resources are available under DABS. The newest addition is the Vector Search Endpoint. #databricks [https://medium.com/@databrickster/databricks-news-watermark-based-incremental-ingestion-mcp-in-ai-gateway-void-bba5021b29de](https://medium.com/@databrickster/databricks-news-watermark-based-incremental-ingestion-mcp-in-ai-gateway-void-bba5021b29de)

I built a VS Code extension for inspecting Databricks Asset Bundles locally

I kept catching issues too late, broken dependencies, misconfigured parameters, stale parameters in notebooks, only after running `databricks bundle validate`. So I built something to make it easier to review locally before deployment. It uses the validation output from the Databricks CLI to help you inspect bundle resources, jobs, tasks, dependencies, parameters, and validation output, directly in VS Code. It is still early, but I would love to know: **what additional features would you expect from a tool like this, or what do you think is missing?** At the moment, it works best for jobs, but I will be rolling out to pipelines soon. GitHub repo: [https://github.com/uncoverthestack/databricks-bundle-inspector](https://github.com/uncoverthestack/databricks-bundle-inspector) VS Code Marketplace: [https://marketplace.visualstudio.com/items?itemName=UncoverTheStack.databricks-bundle-inspector](https://marketplace.visualstudio.com/items?itemName=UncoverTheStack.databricks-bundle-inspector) There is also a demo of how it works in the README as well.

Any tips for DABs in CI/CD? Seems pretty useless so far.

We've used DAB-commands like Validate and Plan for a while - to print Github PR-comments on what the PR will change, delete and create. But we are struggling to catch breaking changes before they are committed to main. Some examples: After migrating a pipeline to serverless compute, our branch passed the plan in the PR stage, but failed in main due to `You must use the Advanced edition when using serverless compute. (400 INVALID_PARAMETER_VALUE)` which is something I would expect CI to catch. Another example is Lakeflow generating a new pipeline-ID, which means during deploy it will try to apply itself to an existing pipeline and fail on mismatching pipeline-ids. Again, would've loved to fail in CI instead of main. How are you solving this?

[Passed] Databricks DEA Exam today

https://preview.redd.it/z6mcmrgvmjyg1.png?width=474&format=png&auto=webp&s=28e010f62635d49af3a815998011125d8f2cfa0f Just walked out of the exam and I’m glad to say I passed. I was sweating a bit because the exam content changes on the 4th, so I really didn't want to fail and have to deal with a new syllabus. I've had Databricks at work since late 2023. I’ve been using it because, well, it’s there, but I was mostly just "vibe coding"—picking up some Python and Spark here and there without any real depth. I ran jobs using whatever cluster settings the company gave me without actually knowing what they meant. If you’ve never touched Databricks, this exam is going to be a pain. Even if you’re good at coding, the internal components and the way everything fits together are hard to grasp just by reading. You really need to get your hands dirty in the workspace to get a "feel" for it. **Study Routine** I started with the Databricks Academy stuff, but since I’m juggling work and a toddler, I could only study on weekends. This was a disaster because by the next Saturday, I’d already forgotten what I learned the week before. One month before the exam, I ditched the theory and just hammered Mock Exams. * Udemy is your friend: I bought practice exams from Derar and Santosh. * I snagged them at discounted price. Just wait for the sale if you are not in a hurry. Personally, Santosh’s exams felt closer to the real thing. I saw maybe 5-6 questions that were almost word-for-word. Derar is also solid; honestly, just solve as many problems as possible. Since my study time was limited, I focused on reviewing the questions I got wrong. I realized pretty early that Productionizing Data Pipelines was my weak spot. I didn't try to become an expert in it. I just aimed for a 60% "pass" in that section and doubled down on the areas I was actually good at. Don't completely ignore your weak areas though. If you bomb one section too hard, a couple of silly mistakes in other sections will kill your score. **What's on the exam** The questions are mostly scenario-based. You have to read the prompts carefully. Some things I remember: * Autoloader: This came up a lot. * DLT (now called Lakeflow Spark Declarative Pipelines): should understand what it actually does * Unity Catalog: Permissions (Granting minimum access) and the actual SQL code for it. * Delta Sharing: Knowing the difference between sharing with Databricks vs. non-Databricks users. * Egress Costs: How to avoid them in cross-cloud sharing (Cloudflare R2 was the answer for one). * SQL Warehouses: Classic vs. Pro vs. Serverless. Know when to use which. * DABs (Databricks Asset Bundles): I got at least 3 questions on this. Don't skip it. * Medallion Architecture: It’s not just "what is Bronze/Silver/Gold." They’ll give you a scenario and ask which layer the data should go to next. Also, those "select two" questions are the absolute worst, super confusing. I know the syllabus is changing on the 4th, so I’m not sure how much of this will still apply. But honestly, if you have some background and get familiar with the core concepts, it’s a very doable exam. I’ve learned a lot through this process. Good luck to everyone preparing!

How are people managing Delta table schemas on Databricks? I use alembic in Python FastAPI Microstructures. I was wondering if Liquibase is a good choice and whether there is a significant advantage of using it over DABs or if they can be combined to have the best of both worlds.

As per title.

Dashboards and DABs; a lesson

Here's a friendly reminder that you should always deploy your dashboards with DABs. I learned that the hard way today. I had some dashboards deployed to customers checked out in my Git folder. Then i decided to work on a different feature thinking that the dashboards were bound to the workspace. In this situation they are not and they Vanish when the branch changes. There were some fraught moments before i got the DABs set up and dashboards redeployed. So, the morale kids: don't be like me, deploy with confidence; deploy with DABs.

DABs Python Mutators: Stop Copy-Pasting the Same Config Across 50 Jobs

# Situation You've got 30, 50, maybe 100 jobs in your Declarative Automation Bundle. Every single one needs failure notifications. Every single one needs cost-center tags. Every single one needs the right cluster policy. And every time someone adds a new job, they forget at least one of those things. You could write **one Python function** that enforces it automatically at deploy time. That's what DABs Python mutators do. # What Are Mutators? A mutator is a Python function that runs during `databricks bundle deploy`. It receives every job (or pipeline) in your bundle, whether defined in YAML or Python, and returns a modified copy. Think of it as middleware for your deployment config. Write a tag, permission, or compute standard once, and apply it automatically to every resource at deploy time. No drift. Decorate a function with  \`@job\_mutator\`, \`@pipeline\_mutator\`,  \`@schema\_mutator\`, or \`@volume\_mutator\`. The function receives the resource + bundle context, and returns a transformed copy. You register them in `databricks.yml`: python: mutators: - 'mutators:add_pipeline_mutators' # Example This example defines common pipeline standards for every pipeline in your bundle: * Specifies common tags. * Enforces serverless compute. * Defines default notifications group and when to trigger an alert. ​ from databricks.bundles.core import Bundle, pipeline_mutator @pipeline_mutator def add_pipeline_mutators(bundle: Bundle, p: Pipeline) -> Pipeline:     p = replace(p, tags=_add_common_tags(bundle, p.tags))     p = replace(p, serverless=True)     default = Notifications.from_dict(        { "email_recipients": "${var.recipients}",          "alerts": ["on-update-failure", "on-update-fatal-failure", "on-flow-failure"] }     )     p = replace(p, notifications=[default])     return p Other resources: * The [bundle-examples](https://github.com/databricks/bundle-examples) repo has a working example at [knowledge\_base/job\_programmatic\_generation](https://github.com/databricks/bundle-examples/tree/main/knowledge_base/job_programmatic_generation). * And as well the documentation page: [https://docs.databricks.com/aws/en/dev-tools/bundles/python/#modify-resources-defined-in-yaml-or-python](https://docs.databricks.com/aws/en/dev-tools/bundles/python/#modify-resources-defined-in-yaml-or-python) # Use Cases https://preview.redd.it/2v2ikiexd4yg1.png?width=632&format=png&auto=webp&s=fa39246e3830b857f1da43777aacfb1079a261a8 Job Mutator Examples: * Enforce default email notifications, owners, tags. * Standardize job clusters / serverless environments. * Inject common job parameters or health/queue settings. Pipeline Mutator Examples: * Enforce pipeline cluster / environment settings. * Apply consistent configuration, catalog/schema, or triggers across all pipelines. Schema Mutator Examples: * Apply standard permissions or tags to all schemas. * Enforce naming conventions or lifecycle settings. Volume Mutators: * Set default storage locations, ACLs, or lifecycle flags. * Add org‑wide tags or conventions to all volumes.

I built a reusable DABs template for multi-environment bundle projects (open source)

I've been working with Databricks Asset Bundles (recently renamed to Declarative Automation Bundles, same DABs acronym) on my project for over a year now. At some point I realized the setup I'd landed on was general enough to be reusable, so I spent about three months of evenings and weekends turning it into a proper Databricks CLI template. It ended up being more comprehensive than what I run on my own project, honestly. You run `databricks bundle init <repo-url>`, answer some prompts (cloud provider, compute type, CI/CD platform, environment setup), and it generates a complete bundle project with: - Multi-environment targets (user/stage/prod, optional dev) - Schema-per-user dev isolation (dbt-style approach: everyone shares the dev catalog, schemas prefixed with username) - CI/CD pipelines for GitHub Actions, Azure DevOps, or GitLab - Medallion architecture schemas as bundle resources - Configurable compute (classic, serverless, or both) - Optional RBAC with environment-aware groups It uses the new direct deployment engine (requires CLI v0.296.0+), so no Terraform dependency. The generated project comes with docs, a quickstart guide, and sample pipelines to start from. Repo: https://github.com/vmariiechko/databricks-bundle-template Example output: https://github.com/vmariiechko/databricks-bundle-template-example MIT licensed. Happy to hear feedback or answer questions about the design decisions. And if something doesn't fit your setup, issues and PRs are welcome.

Heading into the May 2026 Databricks Data Engineer Associate Exam? Read this first.

So if you've been scrolling through older study guides for the Databricks Data Engineer Associate exam — be careful. The syllabus got a pretty big update this month, and the focus has shifted toward the platform's newer declarative features. I spent some time going through the new guidelines. Here's what I found. Lakeflow is the new standard. The exam has moved away from manual ETL logic. You need to understand Lakeflow Spark Declarative Pipelines (formerly DLT) and how Streaming Tables and Materialized Views actually differ. If your notes still say "DLT" everywhere, time to update them. DABs are no longer a side topic. Databricks Asset Bundles — basically infrastructure-as-code for workflows — is now a core part of the exam. They want to see that you can deploy through DABs, not just click around the UI. Unity Catalog is the default assumption. No more legacy Hive Metastore questions. The exam lives in a UC-enabled world now. Three-tier namespace (catalog.schema.table), Volumes for unstructured data, column-level lineage — that's where your time should go. Serverless Compute is showing up more. When do you pick Serverless SQL Warehouses or Serverless Jobs over classic clusters? That tradeoff — less config overhead vs. less control — is fair game now. The weightings that surprised me → 31% on Processing (Lakeflow, Spark, Streaming Tables) → 18% on Productionizing (DABs, Workflows, deployment) That's almost half the exam right there. Honestly, if you just understand why Databricks is pushing toward declarative tools — letting the platform handle the boring parts so you can focus on the actual logic — a lot of the questions start to make sense. For practice material, BricksNotes has an updated practice test that follows the May 2026 format — 45 questions, 90 minutes, same weightings. → [bricksnotes.com/blog/databricks-data-engineer-associate-new-exam-guide-may-2026](http://bricksnotes.com/blog/databricks-data-engineer-associate-new-exam-guide-may-2026) Good luck to everyone testing this month! Drop questions below if you're stuck on any of the new topics — happy to help where I can.