Pulling data through JDBC, ODBC, or REST clients and scheduling the job
External systems (databases, APIs, SaaS apps) can be pulled into Databricks by running JDBC/ODBC or REST client code inside a notebook, writing results as files to cloud storage or directly as Delta tables in Unity Catalog. These notebooks are then wrapped in Lakeflow Jobs so the ingestion runs on a schedule or trigger without manual intervention.
Must-know
- Notebooks can use standard Python/Scala JDBC drivers (e.g. via Spark's spark.read.jdbc/format('jdbc')) to connect to relational sources, or REST/HTTP client libraries (e.g. requests) to pull data from APIs.
- Spark's JDBC reader supports partitioning options (partitionColumn, lowerBound, upperBound, numPartitions) to parallelize large table pulls and avoid single-connection bottlenecks.
- Data landed via REST calls typically arrives as JSON/text in driver memory or a local file first, then must be converted to a Spark DataFrame and written out (e.g. as Delta) rather than assumed to be distributed automatically.
- Writing directly into Unity Catalog–governed tables requires the cluster or SQL warehouse to have a Unity Catalog-enabled access mode, and the identity running the job needs appropriate USE CATALOG/USE SCHEMA/CREATE TABLE grants.
- Credentials for JDBC connections or API tokens should be stored using Databricks secrets (secret scopes) rather than hardcoded in notebook cells.
- Lakeflow Jobs orchestrate these ingestion notebooks with schedules, triggers, retries, and alerting, and can chain them as tasks alongside downstream transformation steps.
A data engineer connects to an on-premises PostgreSQL database from a notebook using a JDBC URL with the username and password embedded as plain-text strings, then schedules the notebook as a Lakeflow Job that runs nightly. A security review flags the plain-text credentials. Which approach removes the finding while keeping the job functional?
What you have tried across Databricks DEA's objectives, not a readiness score.
Databricks Intelligence Platform
Data Ingestion and Loading
- Batch, streaming, and incremental loading patterns, and where the data comes from
- Loading files from cloud storage into governed tables with COPY INTO
- Landing data with Auto Loader, and handling schema enforcement and evolution
- Setting up Lakeflow Connect to ingest from enterprise sources reliably
- Pulling data through JDBC, ODBC, or REST clients and scheduling the job
- Choosing the right ingestion method for a given volume, frequency, and governance need
- Bringing semi-structured and unstructured data into governed Delta tables
Data Transformation and Modeling
- Cleaning bronze data into silver tables with PySpark and SQL
- Joining and combining DataFrames with the different join and union types
- Reshaping columns, rows, and arrays in a table
- Deduplicating and aggregating DataFrames
- Tuning Spark's core parameters and measuring what changed
- Building Gold-layer views and tables for BI and analytics
- Validating Silver and Gold datasets for quality
Working with Lakeflow Jobs
Implementing CI/CD
- Branching, committing, and opening pull requests from inside the Databricks workspace
- Promoting one codebase across dev, test, and prod with bundle variables and overrides
- Packaging and deploying jobs and pipelines with Automation Bundles
- Validating and managing bundle deployments from the Databricks CLI
Troubleshooting, Monitoring, and Optimization
- Spotting performance trends in a job's run history
- Reading job status, task graphs, and failure rates to monitor pipeline health
- Diagnosing skew, shuffle, and spill from Spark UI stage metrics
- What Liquid Clustering and predictive optimization actually do
- Diagnosing cluster startup failures, library conflicts, and out-of-memory errors
Governance and Security
Coverage checked against the published exam guide on Jul 26, 2026.
These are independent practice questions, written against this certification's published exam guide. They are not the certification vendor's own questions, and not the real exam.