Imported from mkgs-databricks-demos/aiSkillUpdater (databricks-lakeflow-connect/SKILL.md). Install upstream with npx skills add mkgs-databricks-demos/aiSkillUpdater --skill databricks-lakeflow-connect. Copyright stays with the author.

Lakeflow Connect

Build managed ingestion pipelines that pull from SaaS apps and databases into Unity Catalog Delta tables, governed end-to-end and powered by serverless Lakeflow Spark Declarative Pipelines (formerly Delta Live Tables / DLT).

Status: mixed catalog — 100+ managed connectors are available. GA connectors are production-ready; preview and beta connectors expand coverage for newer SaaS, ads, file-source, database, and community connector scenarios. See the connector catalog below.

What Is Lakeflow Connect?

Managed connectors for ingesting data from SaaS applications and databases. The resulting ingestion pipeline is governed by Unity Catalog and powered by serverless compute and Lakeflow Spark Declarative Pipelines.

Three frames to keep in mind:

• Simple and low-maintenance — no client code to write, no message bus to operate; connector + UC Connection + a serverless pipeline.
• Unified with the lakehouse — credentials stored in UC, output is governed Delta, runs on Jobs and SDP like any other workload.
• Efficient incremental processing — change tracking / CDC / schema evolution / retries are built in.

There are four architecture patterns:

1. SaaS pull — connector reads from an external SaaS via OAuth or API key, lands in a streaming Delta table.
2. Database CDC via gateway — an ingestion gateway runs in the customer's network, stages change events to a UC Volume, a serverless ingestion pipeline applies them as CDC into Delta.
3. Query-based — for sources without native CDC (Oracle / Teradata / SQL Server / PG / MySQL query-based, Snowflake / Redshift / Synapse / BigQuery via Foreign Catalog), the connector issues periodic queries instead of subscribing to a change feed. Supported destination modes include SCD_TYPE_1, SCD_TYPE_2, and APPEND_ONLY.
4. File-source connectors — managed ingestion from collaboration/document repositories such as SharePoint and Google Drive when those connectors are enabled.
5. Community connectors — open-source template-based connectors for custom sources, currently beta.

Is Lakeflow Connect the right tool?

Decide this before you build. Lakeflow Connect is the managed pull path for SaaS apps and databases — it is not the answer for every ingestion intent.

Full reasoning, including the Federation-vs-Connect and Auto-Loader-vs-Connect trade-offs, is in 4-ingestion-decision-tree.md.

Connector catalog

Lakeflow Connect ships 100+ connectors at multiple release stages. GA connectors are production-ready; preview and beta connectors may have feature gates, changing configuration, or support limitations. Always check the per-connector docs before promising production support.

GA connectors

Full coverage in this skill.

Public Preview connectors

Production-supported. Configuration may evolve before GA. Deep coverage is being added incrementally; until then, see the public connector reference for current setup steps.

Beta and Private Preview

Early-access connectors are not production-supported. The list changes month to month; check the public connector reference for current availability.

For the Lakeflow-Connect-vs-Auto-Loader-vs-Federation-vs-Delta-Sharing decision, see 4-ingestion-decision-tree.md.

Required Tools

• Databricks CLI v1.0.0+ for databricks pipelines create and databricks connections create. Verify with databricks --version.
• Databricks SDK for Python (databricks-sdk>=0.85.0) if you prefer SDK over CLI.
• Declarative Automation Bundles if authoring as IaC (recommended for any pipeline that ships to a customer environment).

No extra connector-specific SDK is needed. Lakeflow Connect reuses the pipelines API surface — pipelines are created with an ingestion_definition block instead of a libraries block, but the API and CLI are otherwise the same.

Prerequisites

Confirm before creating any pipeline:

1. A Unity Catalog target — catalog and schema must exist; the service principal or user creating the pipeline needs USE CATALOG, USE SCHEMA, CREATE TABLE, and MODIFY on the target schema.
2. A UC CONNECTION object with credentials for the source. SaaS OAuth U2M connections must be created via the UI (Catalog Explorer); API-key and basic-auth connections can be created via CLI / DAB.
3. For database connectors: network reachability between the gateway (classic compute, customer VPC) and the source database. On-prem requires ExpressRoute (Azure) or Direct Connect (AWS).
4. For file connectors: OAuth scope grants on the SaaS file repo (SharePoint / Google Drive).

Minimal Example — Salesforce ingestion pipeline

The canonical authoring path is JSON to databricks pipelines create --json. (There is no SQL CREATE TABLE … FROM CONNECTION syntax for Lakeflow Connect — that syntax exists only for Lakehouse Federation, which is a different product.)

databricks pipelines create --json '{
  "name": "salesforce_to_uc",
  "ingestion_definition": {
    "connection_name": "my_salesforce_oauth_connection",
    "objects": [
      {"table": {"source_schema": "salesforce", "source_table": "Account",
                 "destination_catalog": "main", "destination_schema": "salesforce_raw"}},
      {"table": {"source_schema": "salesforce", "source_table": "Opportunity",
                 "destination_catalog": "main", "destination_schema": "salesforce_raw"}}
    ]
  }
}'

For a DAB-authored version (the production path), see 1-saas-connectors.md.

Running the pipeline

Once authored, deploy and trigger a run. The bundle path gives the cleanest run-by-key command:

databricks bundle deploy -t dev
databricks bundle run salesforce_ingestion           # KEY = the pipeline resource key in the bundle; waits by default
databricks bundle run salesforce_ingestion --no-wait

A pipeline created imperatively with pipelines create --json has no run-by-name CLI — start and poll an update by pipeline ID instead:

databricks pipelines start-update <pipeline-id>             # returns an update_id
databricks pipelines get-update  <pipeline-id> <update-id>  # poll one update's status
databricks pipelines list-updates <pipeline-id>             # recent updates and their states

That asymmetry is one more reason to author with a Declarative Automation Bundle.

Detailed guides

Workflow

For each new ingestion pipeline:

1. Pick the connector category — SaaS / database / file / push — and read the matching reference file.
2. Verify prerequisites — UC target, source credentials, network path (for databases), region availability.
3. Create the UC CONNECTION — UI for OAuth U2M, CLI / DAB for everything else.
4. Author the pipeline — databricks pipelines create --json for one-offs, DAB YAML for anything shipping to a customer.
5. Trigger the first run and watch the event log; see 5-troubleshooting-and-monitoring.md for the SQL.
6. Schedule the pipeline directly with one or more custom Lakeflow Connect schedules. Lakeflow Connect auto-creates a Databricks Job for each schedule; use external Jobs orchestration only for broader multi-task workflows.

Anti-patterns

Three forms that look plausible but fail — wrong vs. right:

1. CREATE TABLE ... FROM CONNECTION is Lakehouse Federation, not Lakeflow Connect.

-- WRONG: Federation syntax; no LFC equivalent exists
CREATE TABLE main.salesforce_raw.account FROM CONNECTION my_salesforce_conn;

// RIGHT: author an ingestion_definition (see the Minimal Example above)
{"ingestion_definition": {"connection_name": "my_salesforce_conn", "objects": [/* ... */]}}

2. An ingestion pipeline carries ingestion_definition, never a libraries block.

// WRONG: libraries is for a standard SDP pipeline running your notebooks/files
{"name": "salesforce_to_uc", "libraries": [{"notebook": {"path": "/Repos/.../ingest"}}]}
// RIGHT:
{"name": "salesforce_to_uc", "ingestion_definition": {"connection_name": "...", "objects": []}}

3. continuous: true is rejected — use pipeline schedules instead.

// WRONG: continuous mode fails at create
{"continuous": true, "ingestion_definition": {/* ... */}}
// RIGHT: continuous:false (or omit) + direct Lakeflow Connect pipeline schedules
{"continuous": false, "ingestion_definition": {/* ... */}}

Define custom schedules on the pipeline for recurring ingestion. Lakeflow Connect creates a Databricks Job for each schedule.

Important

• Scheduled or on-demand execution — define one or more custom schedules directly on the pipeline, or trigger runs on demand. Lakeflow Connect auto-creates a Databricks Job per schedule. Check the connector reference for connector-specific schedule limits.
• Compute-only billing — Lakeflow Connect is billed in DBUs (no per-row fee). Database connectors also incur classic-compute gateway DBUs in addition to the serverless ingestion pipeline DBUs. See the pricing page for current rates.
• Salesforce auth is OAuth U2M only — no machine-to-machine, no basic auth. Connection creation requires a UI walk-through.
• Database staging retention is 30 days by default in the UC Volume between the gateway and the ingestion pipeline.
• Limits per pipeline — most SaaS connectors cap at 250 tables per pipeline. Split across multiple pipelines if needed.
• This lands raw tables — Lakeflow Connect writes source-faithful tables (the ingestion landing zone). Build the medallion Bronze/Silver/Gold transforms on top of them with databricks-pipelines.

Key Concepts

• UC CONNECTION is the credential anchor — every Lakeflow Connect pipeline points at a UC connection. The connection owns the auth; the pipeline references it by name.
• Serverless ingestion pipeline + (optional) classic gateway — SaaS connectors are pure serverless. Database connectors split into a customer-network gateway (classic) and a serverless ingestion pipeline (Delta-bound).
• CDC and schema evolution are built in — for sources that support change tracking or CDC, the connector applies changes incrementally and evolves the target schema. Data-type changes typically require a full snapshot reload.
• Streaming Delta output — destination tables are governed Delta tables; CDC sources are applied with change semantics (APPLY CHANGES / AUTO CDC, or apply_changes_from_snapshot for snapshot sources). Compatible with downstream materialized views and Spark streaming.
• OAuth U2M is UI-only — DAB / CLI cannot bootstrap OAuth U2M connections. Hand the one-time browser step to a human (Catalog Explorer > External Data > Connections > Create connection > pick the source > sign in), then resume once databricks connections get <connection_name> reports READY.

Common Issues

For common errors and their fixes — duplicate-key violations, watermark / cursor problems, schema evolution, gateway region availability, the channel runtime-channel setting, and pipelines that run but land no data — see 5-troubleshooting-and-monitoring.md, which also has the event-log queries to diagnose them.

Related Skills

• databricks-pipelines — the SDP runtime that Lakeflow Connect pipelines run on. For Auto Loader and downstream pipeline patterns.
• databricks-zerobus-ingest — push-based gRPC ingestion. Sibling to Lakeflow Connect's pull-based connectors.
• databricks-dabs — author Lakeflow Connect pipelines as IaC.
• databricks-unity-catalog — managing catalogs, schemas, and the UC CONNECTION objects that LFC credentials live in.
• databricks-jobs — orchestrate ingestion pipelines with downstream tasks when a larger workflow needs dependencies.

Row Filtering During Ingestion

Lakeflow Connect supports GA row filtering for managed ingestion pipelines. Use filters to reduce source load, destination storage, and downstream processing by applying SQL WHERE-like conditions during both the initial load and incremental updates.

Supported patterns:

• SaaS connectors where the connector exposes filterable fields
• Query-based connectors where the query or connector configuration can apply predicates
• Initial load and incremental updates so the destination only receives rows matching the filter

Example configuration fragment:

row_filter: "status = 'ACTIVE' AND created_date >= '2024-01-01'"

Validate filter syntax against the connector documentation and source field names. Prefer server-side filters that align with source indexes or partition fields.

Scheduling Model

Lakeflow Connect pipelines can define multiple custom schedules directly on the pipeline. Lakeflow Connect creates and manages a Databricks Job for each schedule, so do not tell users that recurring ingestion requires a separate manually-authored job wrapper.

Use direct pipeline schedules when the user asks for hourly, daily, weekly, or multiple cadence ingestion from the same connector. Reserve external Jobs orchestration for multi-step workflows that need dependencies around the ingestion pipeline.

Free Tier

Lakeflow Connect includes a free tier of 100 free DBUs/day, supporting up to 100M records daily across managed connectors. Treat this as planning guidance and confirm current pricing/entitlement for the user's cloud, region, and account before quoting costs.

Resources

• Lakeflow Connect public docs hub
• Connector reference (per-connector setup)
• Pricing