What you will be able to do
- Ship changed feature logic as a new feature view version without affecting models trained on the old version
- Promote one set of feature definitions through Dev, Test and Prod with only the target environment changing
- Explain what target lag guarantees, how DOWNSTREAM lag chains through dependent dynamic tables, and how incremental and full refresh affect cost and freshness
- Keep online and offline feature values consistent by matching refresh_freq and online target_lag in every environment
- Pick a warehouse or a compute pool to run a feature transformation, and know which settings scale batch and near-real-time features
Key concept
Feature view version as the release unit — A registered feature view's pipeline is frozen. When the logic changes, you publish a new version. Feature logic therefore gets released on its own schedule: models stay pinned to the version they were trained on, and each environment runs exactly the versioned definition it was given.
1.Versioning feature logic separately from model code
A feature becomes an asset when its transformation lives outside every model that uses it. A feature view holds the pipeline that turns raw data into features. You can write that logic in SQL or Snowpark Python, and Snowflake keeps it in the feature store schema rather than in a training script. If three models read customer_spend, all three share one definition. None of them carries its own copy of the aggregation.
Versions are how that shared logic gets released. Registering and retrieving a version is covered in Registering and versioning feature views. Here, what matters is what happens after registration. Once a version is registered, its pipeline cannot change, and the feature store will not let you edit it in place. Only three properties of a registered version can be updated: the refresh frequency, the warehouse the transforms run on, and the description. Feature definitions and columns are fixed.
fs.update_feature_view(
name="<name>",
version="<version>",
refresh_freq="<new_fresh_freq>", # optional
warehouse="<new_warehouse>", # optional
desc="<new_description>", # optional
)Suppose a team wants to widen a 30-day spend window to 90 days. They register the new query as v2 of the same feature view. v1 keeps computing the 30-day value for the models already in production, and each model moves to v2 after it has been retrained and validated on it. The tempting shortcuts each break this release model:
- Passing a new query to
update_feature_viewfails, because the query is not one of the updatable properties. - Running
CREATE OR REPLACE DYNAMIC TABLEon the backing table silently changes values that models trained onv1depend on. - Moving the aggregation into each model's inference code ties feature logic back to model repositories, which is the coupling versioning exists to remove.
Checkpoint 1 of 8· Fill the gap
Version 1 of a feature view is registered and in production. The team wants its transforms to run on a larger warehouse and refresh more often, without publishing a new version. Which feature store method completes this call?
fs. ? (
name="<name>",
version="<version>",
refresh_freq="<new_fresh_freq>", # optional
warehouse="<new_warehouse>", # optional
desc="<new_description>", # optional
)update_feature_view changes a registered version in place, but it only accepts three properties: refresh frequency, warehouse and description. That covers this request. Changing the feature logic or columns would need a new version instead.
Checkpoint 2 of 8· Exam question
A retail team owns a managed feature view customer_spend (version v1) that three production models already read. A data scientist needs to change the aggregation window from 30 to 90 days without disturbing those models, and the transformation logic must stay independent of any model repository. What is the correct approach?
Correct answer: A — Register the updated Snowpark transformation as a new version, v2, of the same feature view, and let each model move to it when it is retrained and validated.
- A. Feature view versions are immutable snapshots of a transformation. Registering
v2besidev1lets existing models keep reading the old definition while new consumers adopt the new window, with no coupling to model code. - B.
update_feature_viewonly changes properties such as refresh frequency, warehouse and description. The defining query of a registered version cannot be replaced in place, and doing so would silently change features under live models anyway. - C. Replacing the underlying dynamic table bypasses Feature Store metadata and changes values for models that were trained on the 30-day window. This produces training/serving skew rather than a controlled version change.
- D. Embedding the transformation in model code is the opposite of treating features as independent assets. Each model would reimplement the logic, and offline and online values would diverge.
Sources1
2.Promoting feature pipelines across Dev, Test and Prod
Every environment should run the same versioned logic. Only the location it runs in should differ. The declarative Feature Store workflow is built for this. You describe entities, data sources and feature views as files in a project directory, keep them in Git, and deploy the same files to each environment. Because the definitions are plain files, CI/CD pipelines can validate, test and promote them.
The environments themselves are declared as deployment targets in manifest.yml. A target names the account, database, schema and role. Source files can leave out database and schema, and the planner fills in whichever target you pick with --target. The YAML that ran in dev is the same YAML that reaches prod.
manifest_version: 1
type: feature_store
default_target: dev
targets:
dev:
account_identifier: MY_ORG-MY_ACCOUNT-DEV
database: MY_FS
schema: FEATURES
role: DATA_SCIENTIST
staging:
account_identifier: MY_ORG-MY_ACCOUNT-STAGING
database: MY_FS
schema: FEATURES
role: FS_ADMIN
prod:
account_identifier: MY_ORG-MY_ACCOUNT-PROD
database: MY_FS
schema: FEATURES
role: FS_ADMINEach promotion is a plan-then-apply step. snow feature plan compares the local definitions with what is deployed in the target and shows a diff of what would be created, updated or deleted. Nothing changes until snow feature apply runs. A reviewer can approve the prod diff before it lands, and repeated applies make only incremental changes.
The declarative path limits how you can write the logic. Batch feature views take a SQL string, and streaming feature views take a pandas UDF. Snowpark DataFrame logic prototyped with the imperative SDK has to be rewritten in one of those forms first. Teams that stay on the imperative Python SDK get the same guarantee another way: one versioned module, deployed from CI to every environment, where only database, schema and warehouse are supplied as parameters. The anti-patterns are the opposite of this. Hand-edited copies per environment drift apart. Pointing Dev and Test at Prod's tables means the lower environments never run the pipeline at all.
Not every pipeline is a dynamic table. Passing refresh_freq=None creates an external feature view, and then you maintain the feature table yourself, for example with dbt. When Snowflake is not refreshing the table for you, a scheduled task, promoted alongside the definitions, is what keeps it current. Building those schedules is covered in Task graphs (DAGs) for ML pipelines.
Checkpoint 3 of 8· Check yourself
A team keeps its declarative feature store project in Git and has tested a feature view change in staging. Before anything changes in prod, a reviewer must approve exactly what will change. What should the CI pipeline do?
snow feature plan compares the local definitions with what is deployed in the chosen target and changes nothing, so the prod diff can be reviewed first. snow feature apply then deploys the same files, and only the target's location and role differ. Hand-edited copies for each environment drift apart. Sharing prod's tables means the lower environment never runs the pipeline at all.
“Nothing is applied until you explicitly run snow feature apply.”Source: docs.snowflake.com
Checkpoint 4 of 8· Exam question
A platform team keeps feature pipeline code in Git and must promote it from Dev to Test to Prod with identical transformation logic. Each environment lives in its own Snowflake database. Which promotion design best preserves consistency between environments?
Correct answer: A — Deploy the same versioned Python module from CI to each environment, passing database, schema and warehouse as parameters to FeatureStore and register_feature_view.
- A. One parameterized artifact means only environment settings differ between stages. The promoted logic is byte-identical, so a feature view tested in Test behaves the same in Prod.
- B. Independent copies drift, so what is validated in Test is not what runs in Prod. Promotion should move one tested artifact, not rely on manual reconciliation.
- C. Sharing Prod objects with lower environments prevents testing changes in isolation and exposes production data to experimentation. Dev and Test need their own feature store schemas.
- D. CSV exports lose dependency, lag and metadata details, and manual re-creation is error-prone. This is neither automated nor repeatable promotion.
3.What target lag guarantees and how it chains
A Snowflake-managed feature view is backed by a dynamic table, and refresh_freq is what makes it managed. The dynamic table's freshness setting is target lag. Target lag sets how stale the data may get. It is not a schedule. TARGET_LAG = '10 minutes' means the data should never be more than ten minutes old. It does not mean a refresh runs every ten minutes.
Target lag is also best-effort. Snowflake schedules refreshes to meet it, but warehouse size, data volume, query complexity and pipeline depth can push actual lag past the target. Refreshes of one table never overlap. If refreshes regularly take longer than the target, staleness keeps exceeding it. The minimum is 60 seconds, and you change it with ALTER DYNAMIC TABLE <name> SET TARGET_LAG = '<duration>'.
DOWNSTREAM belongs on intermediate tables, never on the last table in a pipeline. A table set to DOWNSTREAM has no schedule of its own. It refreshes only when a dynamic table that reads from it needs fresh data, and it follows the shortest target lag among those consumers. Lag is always measured against the base tables at the root of the pipeline, not against the table directly upstream. A consumer therefore cannot be fresher than its source.
| dt_orders | dt_orders_daily | Result |
|---|---|---|
| DOWNSTREAM | 10 minutes | Recommended: the final table stays within 10 minutes, and the upstream table refreshes on demand |
| 5 minutes | 10 minutes | Valid: the final table reads upstream data that is at most 5 minutes stale |
| 10 minutes | DOWNSTREAM | Avoid: the final table never refreshes and returns stale or empty data |
| DOWNSTREAM | DOWNSTREAM | Neither table refreshes automatically, so only a manual refresh runs the pipeline |
| 1 hour | 10 minutes | Invalid: Snowflake raises an error |
The refresh mode decides how much work each refresh does. INCREMENTAL processes only the rows that changed since the last refresh. FULL recomputes the whole result. AUTO, the default, picks one of the two once, when the table is created, and does not reconsider. If a later upstream change makes incremental refresh impossible, refreshes fail. They do not quietly switch to full. Changing the mode means recreating the table.
For feature views, incremental refresh requires change tracking on every source table. Snowflake tries to enable it, which requires OWNERSHIP of the table. If you don't own a source table, either ask its owner to enable change tracking or register with refresh_mode='FULL' and accept a full read on every refresh. A query that can't be maintained incrementally falls back to full refresh at the set frequency, which can add lag and cost. You can split the query into smaller parts that support incremental refresh, or give it a larger warehouse.
Checkpoint 5 of 8· Check yourself
Monitoring shows that a feature view's dynamic table, set to TARGET_LAG = '10 minutes', regularly takes about 15 minutes to refresh. How does Snowflake handle this?
Target lag is a best-effort limit on how stale the data can get. It is not a refresh interval, and refreshes of the same table never run at the same time. If refreshes keep taking longer than the target, actual staleness goes over the target. Snowflake does not switch refresh modes on its own.
“If refreshes consistently take longer than the target lag, actual staleness exceeds the target.”Source: docs.snowflake.com
4.Refresh cadence and online/offline parity
Parity starts with a single definition. Why point-in-time correctness matters for training is covered in Offline/online feature consistency. Operationally, the serving path must read values produced by the same feature view that built the training data. It must not run its own copy of the logic. Recomputing features in the serving application with separate Python is the usual reason offline metrics fail to match production. Enabling online_config on the managed feature view solves this. The online store is then filled from that view's offline values, so training and inference see the same numbers.
profile_fv = FeatureView(
name="USER_BEHAVIOR_PROFILE",
entities=[user_entity],
feature_df=source_df,
timestamp_col="LAST_ACTIVITY_TS",
refresh_freq="1m",
online_config=OnlineConfig(
enable=True,
target_lag="10s",
store_type=OnlineStoreType.POSTGRES,
),
desc="User behavior profile: purchases + engagement from orders and events",
)End-to-end freshness is the sum of two settings. refresh_freq controls how often the offline dynamic table refreshes. OnlineConfig.target_lag controls how often those offline values are copied to the online store. In the example above, source-to-online lag is roughly one minute plus ten seconds. The online target_lag accepts 10 seconds to 8 days, so do not confuse it with the 60-second minimum on dynamic table target lag.
Cadence is where promoted environments drift apart. refresh_freq can be changed on a registered version with update_feature_view. If someone shortens it in Dev and never in Prod, the two environments serve feature values of different ages from identical logic, and a model validated in Test sees fresher inputs than it will get in Prod. Keep refresh_freq and the online target_lag in the versioned definition you promote, and avoid one-off edits in a single environment.
Checkpoint 6 of 8· Fill the gap
In this feature view, the offline dynamic table refreshes every minute. The online store has to copy those offline values within 10 seconds of each refresh. Which OnlineConfig parameter sets that offline-to-online sync?
profile_fv = FeatureView(
name="USER_BEHAVIOR_PROFILE",
entities=[user_entity],
feature_df=source_df,
timestamp_col="LAST_ACTIVITY_TS",
refresh_freq="1m",
online_config=OnlineConfig(
enable=True,
? ="10s",
store_type=OnlineStoreType.POSTGRES,
),
desc="User behavior profile: purchases + engagement from orders and events",
)OnlineConfig.target_lag covers only the copy from the offline store to the online store. refresh_freq is a separate setting that controls the offline dynamic table refresh. The two add up, so source-to-online lag here is roughly one minute plus ten seconds, not 10 seconds.
Checkpoint 7 of 8· Exam question
A fraud model scores transactions through an online endpoint that must read the same feature values used during training. The team currently recomputes features in the serving application with separate Python code, and offline AUC does not match production. Which change best establishes offline/online parity?
Correct answer: A — Enable online_config on the managed feature view so the online store is populated from the same definition and serving reads the online values.
- A. With an online configuration, Snowflake maintains the low-latency online store from the same feature view definition that feeds offline training sets. One definition serves both paths, which removes the duplicated logic that caused the skew.
- B. Tests detect divergence only after the fact and still leave two implementations to maintain. Parity comes from sharing a single definition, not from comparing two.
- C. Changing refresh cadence does nothing to align transformation logic. It could widen staleness gaps and make the discrepancy between training and serving worse.
- D. A second copy refreshed on its own schedule is another pipeline that can drift from the original. It adds latency and maintenance instead of providing a single source of truth.
Sources6
5.Scaling feature computation on warehouses or compute pools
The first scaling decision is which engine runs the transformation. SQL and Snowpark feature views run on a virtual warehouse: the dynamic table's refreshes execute there. Snowflake ML preprocessors also push work down to the warehouse and spread it across warehouse compute. For custom large-scale work, especially on unstructured data, Ray map_batches runs in parallel across the nodes of a compute pool in Container Runtime. Familiar open-source preprocessors suit small and medium data and run in memory on a single node.
| Option | Runs on | Scale lever |
|---|---|---|
| SQL or Snowpark managed feature view | Warehouse (dynamic table refresh) | Change the warehouse with update_feature_view; split the query so it can refresh incrementally |
| Snowflake ML preprocessors | Warehouse (pushdown) | Large or distributed data, spread across warehouse compute |
| Ray map_batches | Compute pool, across nodes | Single-node or multi-node Container Runtime |
| OSS preprocessors such as scikit-learn | Compute pool, in memory | Small and medium datasets only |
Batch scaling on a warehouse comes down to making each refresh finish within the target lag. Moving a version to a larger warehouse needs no new version, because the warehouse is an updatable property. That only treats the symptom if the query has fallen back to full refresh. In that case, restructuring the query for incremental refresh does more than adding compute.
Near-real-time features have a hard floor on the batch path: a managed feature view refreshes at most once a minute, and the online sync adds its own lag on top. When a feature must reflect events within a minute or two, use stream feature views. They ingest events as they arrive and reach end-to-end freshness under 2 seconds. Serving capacity then depends on the online service size. Sizes run from XS (prototyping only, and it can't be resized later) to 3XL. Each step up roughly doubles memory and serving headroom. Larger sizes handle more concurrent reads and ingest throughput but cost more. The working set, meaning entity keys multiplied by feature size across all online views, is usually what decides the size.
Checkpoint 8 of 8· Check yourself
A fraud-scoring model needs each card's transaction-count feature to include events from the last few seconds. Today the feature comes from a managed batch feature view with offline-to-online sync. What change meets this requirement?
A managed feature view refreshes at most once a minute, and the online sync adds its own lag on top. A larger warehouse cannot get past that limit, and a dynamic table target lag must be at least 60 seconds. Stream feature views ingest events as they arrive and reach end-to-end freshness under 2 seconds.
“Stream ingest: Features update as events land in the ingest endpoint. Use stream feature views when you need sub-minute freshness.”Source: docs.snowflake.com
Sources
(7)
Every claim above is drawn from one of these pages, quoted as it was written on the date shown.
- 1.
“Feature definitions and columns cannot be modified. To change the features in a feature store, create a new version of the feature view.”
↩︎ Versioning feature logic separately from model code“You can write feature transformations in SQL or Snowpark Python.”
↩︎ Versioning feature logic separately from model code“You are responsible for maintaining the feature table, updating features from raw data as needed”
↩︎ Promoting feature pipelines across Dev, Test and Prod“create the feature view with refresh_mode='FULL', which fully reads the source table for each refresh.”
↩︎ What target lag guarantees and how it chains“The warehouse where the feature transforms execute”
↩︎ Scaling feature computation on warehouses or compute pools“A feature view pipeline definition is immutable after it has been registered”
↩︎ Key concept“Feature definitions and columns cannot be modified. To change the features in a feature store, create a new version of the feature view.”
↩︎ Exam trap 1 - 2.https://docs.snowflake.com/en/developer-guide/snowflake-ml/feature-store/feature-development-lifecycleOfficial docs
“you can integrate them into CI/CD pipelines to automatically validate, test, and promote features across development, staging, and production environments.”
↩︎ Promoting feature pipelines across Dev, Test and Prod“so the same files work against any target listed in manifest.yml”
↩︎ Promoting feature pipelines across Dev, Test and Prod“Nothing is applied until you explicitly run snow feature apply.”
↩︎ Promoting feature pipelines across Dev, Test and Prod“Snowpark DataFrame has no declarative equivalent.”
↩︎ Promoting feature pipelines across Dev, Test and Prod - 3.
“Applications should not assume that data is always within the target lag.”
↩︎ What target lag guarantees and how it chains“Target lag is measured relative to the base tables at the root of the pipeline, not the direct upstream dynamic table.”
↩︎ What target lag guarantees and how it chains“Target lag is a staleness target, not a refresh interval.”
↩︎ Exam trap 2“Snowflake uses the shortest target lag among all downstream consumers to determine timing.”
↩︎ Exam trap 3“it never refreshes automatically, and Snowflake produces no warning about this.”
↩︎ Prediction“If refreshes consistently take longer than the target lag, actual staleness exceeds the target.”
↩︎ Checkpoint - 4.
“INCREMENTAL processes only the rows that changed since the last refresh. FULL refreshes the entire result set.”
↩︎ What target lag guarantees and how it chains - 5.
“AUTO resolves once at creation time. It does not re-evaluate on subsequent refreshes.”
↩︎ What target lag guarantees and how it chains - 6.https://docs.snowflake.com/en/developer-guide/snowflake-ml/feature-store/online-feature-storeOfficial docs
“It stays integrated with your batch feature pipeline for training while serving the same feature values at inference time.”
↩︎ Refresh cadence and online/offline parity“the effective lag from source data to the online store is approximately refresh_freq + online_config.target_lag.”
↩︎ Refresh cadence and online/offline parity“Set target_lag from 10 seconds to 8 days.”
↩︎ Refresh cadence and online/offline parity“With stream ingestion, end-to-end freshness is under 2 seconds.”
↩︎ Scaling feature computation on warehouses or compute pools“Larger sizes serve more concurrent reads and ingestion throughput at higher cost.”
↩︎ Scaling feature computation on warehouses or compute pools“the effective lag from source data to the online store is approximately refresh_freq + online_config.target_lag.”
↩︎ Exam trap 4“Stream ingest: Features update as events land in the ingest endpoint. Use stream feature views when you need sub-minute freshness.”
↩︎ Checkpoint - 7.
“These APIs distribute the processing across warehouse compute resources.”
↩︎ Scaling feature computation on warehouses or compute pools“Across nodes in a compute pool”
↩︎ Scaling feature computation on warehouses or compute pools