Databricks Data Engineer Professional: Delta Sharing Across Organizations
Delta Sharing is a distribution boundary for data products, not a substitute for governance. The technical mechanism can make a table, view, volume, model, or other governed asset available to another organization without copying the provider’s entire platform, but the provider still has to decide what is being shared, which recipient is entitled to it, how the contract changes, and how access is withdrawn when the relationship ends.
On this page
- Treat the share as a published contract
- Choose the sharing model deliberately
- Share governed objects, not storage accidents
- Plan refresh and change semantics with the recipient
- Worked example: sharing a governed sales data product
- Decide between managed recipient access and open clients
- Handle schema evolution, observability, and revocation
- Governance is the prerequisite, not an optional add-on
Inside Databricks Lakehouse Engineering, sharing belongs after the data product has a stable owner, schema, quality expectation, and lifecycle. A table that changes semantics every week does not become easier to consume merely because it is placed in a share. The sharing layer exposes the product; it does not repair weak product design.
Treat the share as a published contract
A Delta Sharing share should represent a deliberate collection of assets with a business purpose. Do not build one giant share because several teams happen to need data from the same workspace. A smaller contract makes it easier to explain ownership, revoke one relationship, test changes, and report which external parties receive which datasets.
Choose the sharing model deliberately
Databricks supports Databricks-to-Databricks sharing and open sharing patterns for recipients outside the provider’s Databricks environment. Databricks-to-Databricks sharing can use a managed connection between Unity Catalog-enabled environments, while open sharing can support external tools and platforms through supported credentials and clients. The correct model depends on the recipient’s platform, trust model, operational ownership, and automation requirements.
Share governed objects, not storage accidents
Consumers should receive a published object with stable semantics rather than an arbitrary storage path that happens to contain useful files. Unity Catalog provides the governance boundary around catalogs, schemas, tables, views, volumes, functions, models, and other securable assets. That lets the provider reason about ownership and privileges before adding an asset to a share.
Plan refresh and change semantics with the recipient
Shared data can update continuously as the provider publishes new table versions, but consumers may read on a schedule, stream changes, or snapshot the data into their own systems. The provider should state whether corrections overwrite prior state, whether deletes can occur, whether late data is expected, and how far back a consumer can reconstruct history.
Worked example: sharing a governed sales data product
A distributor wants to share daily order and inventory information with a logistics partner. The raw operational database includes employee identifiers, internal pricing negotiations, and fields whose definitions change as applications evolve. Publishing the entire source table would give the recipient more information than needed and make breaking changes hard to manage. Instead the provider designs a stable consumer-facing view with an owner, a documented schema, a freshness expectation, and explicit rules for late corrections.
Before creating a share, the provider validates rows against agreed data-quality checks, classifies sensitive columns, and removes unnecessary fields. It defines a versioning and communication rule: adding an optional column can be announced on an agreed schedule, while changing the meaning of a status value requires explicit notice and recipient testing. The recipient validates a test extract and confirms that its business process can handle deletions and late-arriving transactions.
The share becomes an interface contract. It is not a data integration architecture by itself. The consumer may still need orchestration, validation, alerting, storage controls, and policies for downstream copies. The provider must document what remains under its control after a recipient reads or exports shared data.
Decide between managed recipient access and open clients
When both organizations use Unity Catalog-enabled Databricks workspaces, Databricks-to-Databricks sharing offers native integration and controlled recipient registration. A provider grants recipients access to one or more defined shares, while the recipient’s administrators govern access within their own environment. The connection and supported assets depend on platform and account features, so verify the current requirements before committing to the design.
For partners using other engines, open-protocol sharing may be more appropriate. The recipient can use supported clients rather than receiving a full Databricks workspace. Credential handling, token rotation, network restrictions, and client compatibility become important operational responsibilities. Databricks’ official OpenSharing documentation explains supported provider, share and recipient models; the product terminology may evolve while articles and exam materials still refer to Delta Sharing.
Handle schema evolution, observability, and revocation
A provider should maintain a clear change log for consumers: owner, stable dataset identifier, expected update frequency, supported history, known-quality limitations, and contact for incidents. Test recipient-facing queries before changing partition or filtering behavior. If the contract allows consumers to stream updates or time-travel through versions, define what happens when source history is vacuumed, access expires, or a field must be removed for privacy reasons. Never imply that every protocol supports every history or streaming feature.
Revocation is part of the design. Removing a recipient from a metastore can remove access to shares, but it does not erase copies a recipient may already have exported. Sensitive-data contracts should address permitted downstream use, retention, deletion requests, and audit evidence. Monitor who has access to each share, which datasets are published, and when a consumer last tested compatibility.
Databricks’ share-management guide documents privileges and the supported workflow. A technically successful grant is only one step; the responsible engineering team still owns quality, consumer communications, and the consequences of semantic change.
Governance is the prerequisite, not an optional add-on
Unity Catalog models assets as securable objects, supports discovery and access control, and provides lineage and auditing capabilities. A sensible operating model distinguishes producer permissions from the subset published to a consumer. For a cross-team architecture discussion, see lakehouse governance at scale; it covers the controls that make broad sharing maintainable.
Certification preparation should focus on the provider–share–recipient relationship, access boundaries, supported sharing modes, and operational responsibilities. The worked distribution scenario is an educational example, not a claim that any specific organization or recipient uses these controls. Product behavior can change by cloud and runtime; follow the current Databricks reference for implementation.