CertSafari
    Snowflake SnowPro Advanced: MLOps Engineer (MLA-B01)· Lessons

    Domain 1 · Lesson 5/17

    Features as data assets: versioning, promotion, refresh and scaling

    Operationalize features as first-class data assets.

    18 min read
    4% of exam
    7 sources
    Published 20 Oct 2026
    Docs as of 18 Oct 2026

    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.

    The only in-place edits a registered feature view version acceptspython
    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_view fails, because the query is not one of the updatable properties.
    • Running CREATE OR REPLACE DYNAMIC TABLE on the backing table silently changes values that models trained on v1 depend 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
    )

    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?

    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.

    One project, three deployment targets: only the location and role changeyaml
    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_ADMIN

    Each 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?

    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?

    Sources21

    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.

    Target lag combinations for dt_orders (upstream) feeding dt_orders_daily
    dt_ordersdt_orders_dailyResult
    DOWNSTREAM10 minutesRecommended: the final table stays within 10 minutes, and the upstream table refreshes on demand
    5 minutes10 minutesValid: the final table reads upstream data that is at most 5 minutes stale
    10 minutesDOWNSTREAMAvoid: the final table never refreshes and returns stale or empty data
    DOWNSTREAMDOWNSTREAMNeither table refreshes automatically, so only a manual refresh runs the pipeline
    1 hour10 minutesInvalid: 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?

    Sources3451

    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.

    A managed feature view with online serving enabled: two independent freshness settingspython
    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",
    )

    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?

    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.

    Who runs the transformation, and the lever for scaling it
    OptionRuns onScale lever
    SQL or Snowpark managed feature viewWarehouse (dynamic table refresh)Change the warehouse with update_feature_view; split the query so it can refresh incrementally
    Snowflake ML preprocessorsWarehouse (pushdown)Large or distributed data, spread across warehouse compute
    Ray map_batchesCompute pool, across nodesSingle-node or multi-node Container Runtime
    OSS preprocessors such as scikit-learnCompute pool, in memorySmall 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?

    Sources716

    Sources

    (7)

    Every claim above is drawn from one of these pages, quoted as it was written on the date shown.

    1. 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. 2.
      “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. 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. 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. 5.
      “AUTO resolves once at creation time. It does not re-evaluate on subsequent refreshes.”
      ↩︎ What target lag guarantees and how it chains
    6. 6.
      “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

    Ready to test yourself?

    Practise the 15 questions on this subdomain.

    Spotted a mistake, or was something unclear? Tell us.