1.6 Feature Tables in Unity Catalog vs. the Workspace Feature Store
Key Takeaways
- Feature Engineering in Unity Catalog registers feature tables at the **account** level under `catalog.schema.table`, so any authorised workspace on the metastore can read them.
- The legacy Workspace Feature Store was scoped to a single workspace's Hive metastore, which forced duplicate feature pipelines and cross-workspace sync scripts.
- Unity Catalog feature tables inherit standard SQL privileges (`GRANT SELECT`, `GRANT MODIFY`), audit logging, and automatic end-to-end lineage from source Delta tables through training runs to serving endpoints.
- The client changed with the namespace: `databricks.feature_engineering.FeatureEngineeringClient` replaces `databricks.feature_store.FeatureStoreClient`.
- Any Delta table in Unity Catalog with a `NOT NULL` primary key constraint is usable as a feature table — Feature Engineering in Unity Catalog requires Databricks Runtime 13.2 or above and Privilege Model Version 1.0.
1.6 Feature Tables in Unity Catalog vs. the Workspace Feature Store
In enterprise machine learning, feature reusability, consistency, and governance are paramount. Without a centralized feature platform, disparate data science teams frequently rewrite identical feature transformations (e.g., calculating 30-day average transaction volumes), leading to code duplication, computational waste, and severe train/serve skew.
Feature Engineering in Unity Catalog represents the evolution of the Databricks Feature Store. It replaces legacy, workspace-confined feature stores with an account-level architecture governed under Unity Catalog's standard 3-level namespace (catalog.schema.table).
| Namespace level | Example | What it controls |
|---|---|---|
| Catalog (account level) | prod_catalog | Environment isolation and the coarsest unit teams grant across |
| Schema | ml_features | Grouping of related feature domains |
| Table | customer_360_features | A Delta feature table keyed on customer_id, holding avg_monthly_spend, tenure_months, total_returns |
| Table | transaction_temporal_features | A time-series feature table keyed on account_id with a TIMESERIES column transaction_timestamp, holding rolling_7d_spend and declined_txn_count |
Both tables belong to the metastore rather than to a workspace, which is the entire
point: prod_catalog.ml_features.customer_360_features resolves to the same physical
data from every workspace attached to that metastore.
Workspace Feature Store vs. Feature Engineering in Unity Catalog
Understanding the architectural advantages of Unity Catalog feature tables over legacy workspace feature stores is a primary focus of the Databricks ML certification.
| Capability / Property | Legacy Workspace Feature Store | Feature Engineering in Unity Catalog |
|---|---|---|
| Client Package | databricks.feature_store.FeatureStoreClient | databricks.feature_engineering.FeatureEngineeringClient |
| Namespace Structure | 2-level namespace: database.table (or hive_metastore.database.table) | 3-level namespace: catalog.schema.table |
| Cross-Workspace Access | Complex; required workspace-to-workspace API tokens and custom syncing. | Native; feature tables in a catalog are instantly accessible across all authorized workspaces. |
| Governance & Security | Table ACLs isolated to individual workspace metastores. | Centralized Unity Catalog RBAC (GRANT SELECT / MODIFY ON TABLE) with audit logging. |
| Lineage Tracking | Local to workspace; partial visibility into upstream data sources. | End-to-end automated lineage from raw Delta tables -> feature tables -> MLflow models -> endpoints. |
| Discoverability | Limited to users with access to the specific local workspace. | Account-wide searchable UI catalog with column-level descriptions, tags, and owner metadata. |
Why Account-Level Registration Changes the Economics
The comparison table above lists the mechanical differences. The exam cares about the consequences, which are worth stating explicitly.
One definition, many consumers
A workspace-scoped feature table is invisible outside its workspace. In a typical
enterprise with separate workspaces for marketing, risk, and operations, the same
customer_30d_spend feature gets rebuilt three times, with three slightly different
window definitions. When those teams later compare model results, the discrepancy is
untraceable. An account-level table has exactly one definition, and every team reads
the same computed values.
Governance uses the tools the platform already has
Because a Unity Catalog feature table is a Delta table with feature metadata, access is granted with ordinary SQL:
GRANT SELECT ON TABLE prod_catalog.ml_features.customer_spending TO `data-scientists`;
GRANT MODIFY ON TABLE prod_catalog.ml_features.customer_spending TO `sp-feature-pipeline`;
Column masks, row filters, tags, and audit logs apply the same way they do to any other governed table. The workspace feature store required a parallel permission model that no data governance team could reconcile with the rest of the estate.
Lineage becomes end-to-end and automatic
Unity Catalog records, without instrumentation, that a bronze table fed a feature computation job, that the job wrote a feature table, that a training run consumed particular feature columns, that the run produced a registered model version, and that the version backs a serving endpoint. Two questions become answerable in seconds:
- If this upstream table is wrong, which production models are affected?
- Which features does this production model actually depend on?
Discoverability prevents duplicated work
Account-level tables are searchable in Catalog Explorer with descriptions, tags, and owners. Feature reuse is only possible when engineers can find what already exists.
What changes in your code
| Concern | Workspace Feature Store | Feature Engineering in Unity Catalog |
|---|---|---|
| Package | databricks-feature-store | databricks-feature-engineering |
| Client | FeatureStoreClient() | FeatureEngineeringClient() |
| Table name | database.table | catalog.schema.table |
| Time-series parameter | timestamp_keys=[...] | timeseries_column="..." |
Exam tip: any option that describes copying feature tables between workspaces, or maintaining per-workspace ACL scripts, is describing the legacy architecture and is the wrong answer when Unity Catalog is available.
What Actually Makes a Table a Feature Table
The most commonly missed fact in this objective is that Unity Catalog has no separate feature-table storage type. Any Delta table in Unity Catalog that carries a primary key constraint can be used as a feature table. There is no registration call, no proprietary format, and nothing preventing an analyst from querying it with ordinary SQL.
That single design decision produces most of the benefits listed above. A feature table
is a governed Delta table, so every capability the platform already has — grants, tags,
comments, lineage, Delta history, OPTIMIZE — applies to it with no parallel
implementation.
Requirements to satisfy
| Requirement | Value |
|---|---|
| Databricks Runtime | 13.2 or above for Feature Engineering in Unity Catalog |
| Metastore | Unity Catalog enabled, Privilege Model Version 1.0 |
| Primary key | Required; every primary key column must be NOT NULL |
| Time-series tables | One column marked TIMESERIES (Databricks Runtime 13.3 LTS or above) |
| Ownership | Only the table owner may declare the primary key constraint |
Promoting an existing Delta table
Because the requirement is only a constraint, an existing Delta table becomes a feature table with two DDL statements — no data movement and no rewrite:
ALTER TABLE prod_catalog.ml_features.customer_spending
ALTER COLUMN customer_id SET NOT NULL;
ALTER TABLE prod_catalog.ml_features.customer_spending
ADD CONSTRAINT customer_spending_pk PRIMARY KEY (customer_id);
The order matters: the NOT NULL designation must be in place on every column named in
the key before the primary key constraint is added. The legacy workspace feature store
offered no equivalent path — a table had to be created through the feature store client
and registered in a workspace-local registry, so adopting an existing curated table
meant copying it.
Privileges involved
Setting up the namespace uses ordinary Unity Catalog privileges rather than a feature-store-specific permission model:
CREATE CATALOGon the metastore to create a new catalog, orUSE CATALOGon an existing one.CREATE SCHEMAon the catalog to create the schema that will hold feature tables.SELECTon the table for anyone who trains against it, andMODIFYfor the pipeline identity that writes to it.
A scenario describing a data scientist who can see a feature table in Catalog Explorer
but cannot build a training set from it is almost always missing SELECT — not some
feature-store-specific grant.
Which of the following is a primary architectural benefit of migrating from the legacy Workspace Feature Store to Feature Engineering in Unity Catalog?
Two teams in different Databricks workspaces need the same customer_lifetime_value feature, and a compliance reviewer must be able to see which production models consume it. Which architecture satisfies both requirements?
A team already maintains a curated Delta table prod_catalog.ml_features.customer_spending in Unity Catalog and wants to use it as a feature table for create_training_set. What must they do?