Free Snowflake SnowPro Advanced: MLOps Engineer (MLA-B01) Sample Questions

Correct answer: B — The training set will contain leakage because the aggregate uses future data relative to some label events.

• A. Incorrect. Without an explicit timestamp in the feature view, the aggregates are not tied to a specific point in time, so the training set cannot correctly reflect historical values at event times. The standard GROUP BY aggregate can include data from after the label timestamp, breaking point-in-time correctness.
• B. Correct. Because the feature view lacks an explicit timestamp, the aggregate is computed over all available data, including records that occurred after some label events. This introduces temporal leakage in the training set, making the point-in-time join invalid.
• C. Incorrect. Snowflake does not automatically detect or infer an event timestamp from the base table for a generic GROUP BY feature view. Point-in-time correctness requires the feature definition to be explicitly time-aware.
• D. Incorrect. The refresh schedule of the feature view does not filter labels to only those that align with refresh times. The primary risk here is leakage, not label filtering.

Correct answers: A, B — Compare online feature values for sample entities with training set values at the same timestamps.; Verify that the online serving function implements the same transformation logic as the feature view.

• A. Correct. Comparing online feature values for sample entities with training set values at the same timestamps directly checks whether the two serving paths produce the same values for identical points in time. This is a strong way to diagnose temporal drift or mismatched point-in-time logic, ensuring temporal and value consistency.
• B. Correct. Verifying that the online serving function implements the same transformation logic as the feature view ensures parity between offline and online computations. If the logic differs, feature values can diverge even when the source data is the same, making this a critical diagnostic step.
• C. Incorrect. Increasing the online store cache size may improve latency or reduce cache misses, but it does not address whether the feature values themselves are consistent with training. This is a performance tuning action, not a validation of feature correctness.
• D. Incorrect. Renaming a feature view does not inherently validate or correct online/offline inconsistency, and it will not force a reliable diagnostic comparison. This is unrelated to temporal integrity or feature consistency.
• E. Incorrect. Temporarily serving using the offline feature view SQL in the online path is generally not appropriate for a low-latency online serving architecture and can introduce performance and operational issues. It also does not systematically diagnose the root cause as well as direct comparison and logic verification.
• F. Incorrect. While detailed logging can aid troubleshooting, it is not one of the two primary actions to verify and diagnose the discrepancy. The stronger diagnosis steps are to compare values at the same timestamps and confirm the online logic matches the feature view.

Correct answer: B — The online feature calculation logic uses a different aggregation window than the feature view definition.

• A. Incorrect. Stale values can cause discrepancies, but they typically lead to lagged predictions rather than a consistent downward bias. The feature view definition being unchanged suggests the refresh cycle is likely consistent; the issue is more likely a mismatch in feature computation logic.
• B. Correct. If the online feature calculation uses a different aggregation window (e.g., a shorter or longer time frame) than what was defined in the feature view and used during offline training, the features served online will differ systematically, causing predictions to be lower (or higher) than expected.
• C. Incorrect. Different entity keys would cause missing or misjoined records, but not a systematic directional bias in predictions. The feature view definition ensures consistent keys between training and serving, so this is unlikely.
• D. Incorrect. Training on a smaller sample can lead to optimistic offline metrics, but that does not explain a systematic discrepancy between online and offline predictions. The question points to a feature computation mismatch, not a data sample issue.

Correct answer: C — The training set uses the current timestamp as the point-in-time for all label rows.

• A. Incorrect. The `point_in_time_column` parameter is not mandatory; the function can operate without it, using a default behavior. No error is raised.
• B. Incorrect. Using the most recent feature values for all rows would cause data leakage, as it could use future data. The default uses the current timestamp to maintain temporal integrity.
• C. Correct. If `point_in_time_column` is not specified, Snowflake Feature Store defaults to using the current timestamp (`CURRENT_TIMESTAMP()`) as the point-in-time for all label rows. This ensures feature values are retrieved as of that moment, preventing data leakage.
• D. Incorrect. `generate_training_set` performs a time-aware join that respects temporal constraints based on the point-in-time, not a simple inner join on entity IDs without time constraints.

Correct answer: B — To encapsulate feature transformation logic and serve a consistent training/inference interface.

• A. Incorrect. A feature view is designed for transformed, reusable features, not persisting raw unprocessed source data for ad-hoc analysis. Raw data storage is typically handled by data lakes or raw tables, not the feature store.
• B. Correct. A feature view encapsulates feature transformation logic and provides a consistent interface for both training and inference. This ensures the same feature definitions are used across the model lifecycle, reducing training-serving skew and promoting reproducibility and reusability.
• C. Incorrect. Recording model versions and tracking metadata and dependencies across deployment environments is the role of a model registry or MLOps metadata store, not a feature view. Feature views focus on feature definition and access, not model governance.
• D. Incorrect. Orchestrating external data ingestion on a schedule is an ETL/ELT or pipeline orchestration responsibility. While feature views may consume data prepared by such pipelines, they do not schedule or manage ingestion themselves.

Correct answer: D — fv = fs.create_feature_view(name="cust_features", entities=["CUST_ID"], df=df)

• A. Incorrect. The Feature Store's create_feature_view method expects the DataFrame parameter to be named 'df', not 'feature_df'. Additionally, the snippet passes 'df' as the argument, but the actual DataFrame created in the pipeline is named 'feature_df', causing a mismatch.
• B. Incorrect. The create_feature_view method belongs to the FeatureStore object (fs), not to a Snowpark DataFrame. Calling it on the DataFrame will raise an AttributeError.
• C. Incorrect. The correct method name is 'create_feature_view', not 'register_feature_view'. Additionally, the entity key column should be specified via the 'entities' parameter, not 'keys'.
• D. Correct. This snippet correctly uses the FeatureStore object (fs) to call create_feature_view with the required parameters: name for the feature view name, entities for the entity key columns, and df for the Snowpark DataFrame containing the features. This follows the Snowflake Feature Store API.

Correct answers: A, C — Feature View; Feature Store Entity

• A. Correct. Feature View is a core component that defines the schema and logic for computing feature values for a specific entity, enabling consistent feature retrieval for model training and inference.
• B. Incorrect. Model Registry is used for managing machine learning models and is separate from the Feature Store architecture.
• C. Correct. Feature Store Entity represents the primary object (e.g., customer or product) and serves as the join key, anchoring Feature Views to the entities they describe.
• D. Incorrect. Snowpark UDF is a tool for defining custom logic in feature engineering pipelines but is not a core architectural component of the Feature Store itself.
• E. Incorrect. Dynamic Tables are used for incremental data transformation and refreshing derived data, but they are not a core component of Snowflake Feature Store architecture.

Correct answers: A, C — The database connection details, such as host, port, and credentials.; The name of the source table or the query in the external database.

• A. Correct. The external feature view requires a defined external volume or access integration that specifies the connection details (host, port, credentials) to the PostgreSQL database. Without this, Snowflake cannot connect to the external source.
• B. Incorrect. While the feature view must be registered in a Snowflake schema, the schema is specified as part of the feature view name rather than a separate configuration. The required configurations for creation are the connection details and the source definition.
• C. Correct. The CREATE EXTERNAL FEATURE VIEW statement requires either a TABLE or QUERY parameter to define the data to be pulled from the external database. This specifies which rows and columns are used as features.
• D. Incorrect. A refresh schedule is optional for external feature views, as data remains in the external source and is not automatically materialized. Scheduling is relevant only for materialized or ingested feature pipelines, not for the initial creation.
• E. Incorrect. While a Snowflake role with privileges may be needed for access control, it is not a direct configuration parameter of the external feature view. Access is managed through the external access integration and schema-level permissions.

Correct answer: B — Transformations are lazily built into a query plan that executes only when an action is called.

• A. Incorrect. Snowpark DataFrames are not immediately materialized; transformations are lazily evaluated, building a deferred computation plan that only executes upon an action.
• B. Correct. Snowpark DataFrame transformations are lazily composed into a logical query plan. Execution occurs only when an action (e.g., show(), to_pandas()) is invoked, allowing Snowflake to optimize the entire query.
• C. Incorrect. Transformations do not trigger individual SQL queries. Snowpark combines the full transformation chain into a single optimized query plan executed upon an action.
• D. Incorrect. A Snowpark DataFrame is not stored in an internal stage; it represents a logical plan over Snowflake data until an action materializes the result.

Correct answer: A — Create a data share, add the feature table as a shared object, and grant the partner reader privileges.

• A. Correct. Snowflake data sharing is the native, secure, and efficient method to provide read-only access to feature tables without copying data. Creating a data share, adding the feature table as a shared object, and granting reader privileges to the partner account aligns with Snowflake’s secure data sharing model, allowing real-time access with granular permissions.
• B. Incorrect. Exporting to Parquet and managing IAM roles introduces data duplication, external storage management, and refresh overhead. It is more complex and less secure than native Snowflake sharing.
• C. Incorrect. Database replication is intended for high availability, disaster recovery, or regional expansion, not for sharing feature tables with another account. It replicates entire databases rather than providing selective access and adds unnecessary latency and operational overhead.
• D. Incorrect. Snowpipe is designed for continuous data ingestion into Snowflake, not for distributing tables to other accounts. It would require the partner to maintain their own ingestion pipeline and results in data duplication rather than direct secure access.

Correct answer: A — Construct a Pipeline object containing the two transformers, call fit on the training DataFrame, then transform to obtain the final dataset.

• A. Correct. Snowpark ML provides a Pipeline object that allows chaining multiple transformers. Calling fit on the training DataFrame learns the parameters for all transformers, and transform applies them in sequence. This approach leverages the distributed execution engine without materializing intermediate results.
• B. Incorrect. Materializing intermediate results to a temporary table adds unnecessary I/O overhead and breaks the natural pipeline abstraction. Snowpark ML supports in-memory chaining without intermediate storage.
• C. Incorrect. While Snowflake supports SQL-based feature engineering, nesting table functions for sequential preprocessing like scaling then encoding is not the standard pattern. The Snowpark ML Pipeline is cleaner and better aligned with distributed workflows.
• D. Incorrect. Using a stored procedure and internal stages introduces unnecessary complexity and latency. Snowpark ML provides native pipeline abstractions that avoid materialization overhead.

Correct answer: B — StandardScaler

• A. MinMaxScaler scales features to a fixed range (e.g., 0 to 1), but does not standardize to zero mean and unit variance. It is a supported transformer in Snowpark ML but not for z-score normalization.
• B. StandardScaler removes the mean and scales to unit variance, performing z-score normalization. This is the correct transformer for standardizing numeric features to zero mean and unit variance.
• C. OneHotEncoder converts categorical features into binary indicator columns; it is not used for scaling numeric features.
• D. LabelEncoder is not a supported transformer in Snowpark ML; it is typically used for encoding target labels in scikit-learn.
• E. OrdinalEncoder encodes categorical features as ordinal integers; it is for categorical variables, not numeric standardization.
• F. MinMaxScalerOneHotEncoder is not a valid transformer in Snowpark ML; it appears to be a combination of two separate transformers.

Correct answer: B — Migrate the tasks to serverless compute to reduce idle cost and startup latency.

• A. Incorrect. A Snowpark-optimized warehouse still incurs startup latency and idle costs. Auto-suspend at 1 minute can reduce idle spend but does not eliminate the 1–2 minute startup delay, and may increase resume frequency.
• B. Correct. Serverless compute eliminates idle costs entirely because Snowflake manages the compute lifecycle. It resumes quickly without startup latency, directly addressing both cost and latency while preserving the task DAG.
• C. Incorrect. Compute Pools are designed for Snowpark Container Services, not standard task DAGs. Even if used, a minimum active node incurs continuous cost, failing to reduce overall expenses.
• D. Incorrect. Increasing warehouse size may shorten execution time but does not reduce startup latency or idle costs. It can increase costs and still leaves the warehouse idle after execution.

Correct answers: A, D, E — Use separate Snowflake databases for each environment.; Define dynamic table refresh policies to align schedules.; Promote DDL changes via CI/CD from Dev to Prod.

• A. Correct. Using separate Snowflake databases for each environment provides strong isolation, preventing cross-environment interference and enabling independent management of schemas, tasks, and dynamic tables. This directly supports environment isolation.
• B. Incorrect. Sharing a single warehouse across environments reduces isolation and can cause resource contention, making it harder to control costs and performance independently. This contradicts the goal of environment isolation.
• C. Incorrect. While tagging tasks with environment type improves operational visibility and governance, it does not directly address environment isolation or consistent schedule management, which are the primary goals. It is a supportive practice but not among the three most critical.
• D. Correct. Defining dynamic table refresh policies helps align refresh schedules across environments, ensuring consistent data freshness and predictable pipeline behavior. This directly supports consistent schedule management.
• E. Correct. Promoting DDL changes through a CI/CD pipeline ensures controlled, auditable, and repeatable deployments from Dev to Prod, reducing errors and maintaining consistency across environments. This supports both isolation and schedule management by preventing ad-hoc changes.

Correct answers: B, E — User-defined function (UDF) that imports a versioned Python module.; Snowpark Container Services job with a version label in its spec.

• A. A stored procedure can encapsulate transformation logic, but Snowflake does not natively support a version parameter in its definition for explicit versioning. Any versioning must be manually managed through code deployment or object naming, not as a built-in feature.
• B. A user-defined function (UDF) can package feature transformation logic, and by importing a versioned Python module (e.g., via pip), the transformation code is explicitly tied to a version. This is a common pattern for reproducible feature engineering in Snowflake.
• C. Dynamic tables are used to maintain derived results automatically, but adding a version comment does not create explicit versioning of the transformation logic. Comments are metadata only and do not provide a versioned package mechanism.
• D. External functions call out to external APIs, and the API integration does not provide Snowflake-native explicit versioning for the feature transformation package. Any versioning must be handled externally by the external service, not by the Snowflake object itself.
• E. Snowpark Container Services can run transformation logic in containers, and the job specification can reference a labeled container image version (e.g., Docker tags). This allows feature transformation code to be packaged and deployed with explicit versioning.

Correct answer: A — Increase the warehouse size for more computational resources.

• A. Increasing the warehouse size provides more CPU and memory resources, directly scaling the SQL query's performance for batch feature computation. This is the standard method to speed up a single SQL job.
• B. Compute Pools with GPU nodes are used for Snowpark Container Services, not for scaling SQL queries on standard virtual warehouses. GPUs are not applicable to typical SQL-based batch feature computation in Snowflake.
• C. Multi-cluster mode adds clusters to handle more concurrent queries, but does not accelerate a single SQL query. Since the question focuses on scaling one batch job, this option is incorrect.
• D. Snowpark-optimized warehouses are designed for Snowpark Python/Scala workloads, not for standard SQL queries. They do not benefit SQL-based batch feature computation jobs.

Correct answer: B — SYSTEM$PIPE_STATUS()

• A. Incorrect. SYSTEM$LAST_CHANGE_COMMIT_TIME() returns the timestamp of the last change committed to a table, not the status of a Snowpipe. It is not used for monitoring or troubleshooting pipe execution.
• B. Correct. SYSTEM$PIPE_STATUS() is a table function that returns the current status of a Snowpipe, including whether it is running, paused, or has errors. It provides the operational visibility needed for retraining and automation workflows.
• C. Incorrect. INFORMATION_SCHEMA.TABLES.LAST_ALTERED shows when a table was last modified, not the status of a pipe. While useful for metadata auditing, it does not indicate pipe health or ingestion failures.
• D. Incorrect. GET_DDL() returns the DDL definition for an object, such as a pipe configuration, but does not report runtime status or troubleshooting information. It is suitable for configuration inspection, not for monitoring execution.

Correct answer: B — Upgrade to a 2XL warehouse for the retraining job.

• A. Incorrect. Sampling the data reduces memory usage but reduces training data quantity, potentially degrading model quality. It is a workaround rather than addressing the root cause of insufficient compute or memory.
• B. Correct. Upgrading to a larger warehouse (e.g., 2XL) directly increases available memory and compute resources, allowing the retraining job to complete successfully. In Snowflake, scaling up the warehouse is the most straightforward way to address resource constraints during training.
• C. Incorrect. While incremental learning with mini-batches can reduce memory usage, it requires significant changes to the training algorithm and may not be supported by the existing model workflow. The direct, Snowflake-oriented fix is to increase compute resources via warehouse sizing.
• D. Incorrect. Materializing the feature table can improve query performance by simplifying joins, but it does not directly address insufficient compute or memory for the training process. It may help in some pipelines but is not the best immediate remedy.

Correct answer: A — Set up a Snowpipe to load new data, then a Task that validates quality and calls a training procedure upon success.

• A. Correct. Snowpipe automatically ingests new files from an external stage into a Snowflake table. A downstream Task can be set to run (often using a Stream on the target table) to validate data quality and, if successful, invoke a stored procedure for model retraining. This is the standard event-driven pattern for retraining in Snowflake.
• B. Incorrect. Streams in Snowflake track changes on tables, not on external stages. An external stage is not a table, so a Stream cannot be created directly on it. Therefore, this approach is not valid.
• C. Incorrect. Snowflake Tasks are scheduled on a fixed interval or cron schedule; they cannot be directly triggered by file arrival on an external stage. A Task would need to rely on a Stream or polling after ingestion, making this option inaccurate.
• D. Incorrect. Snowflake Alerts are used to monitor conditions like query performance or resource usage, not to detect new files on external stage metadata. This is not a supported use case for Alerts.

Correct answer: B — Review SPCS logs and metrics for memory and CPU usage.

• A. Incorrect. Query profiling is used for SQL workloads, but SPCS inference does not execute SQL queries, so query profiles are not directly relevant to container-level resource issues.
• B. Correct. SPCS logs and metrics provide direct insight into resource utilization (CPU, memory, restarts) for the container service, making it the most effective first step to diagnose performance bottlenecks.
• C. Incorrect. Increasing instance count is a remediation step, not a diagnostic step. The first action should be to analyze logs/metrics to determine if resource constraints are the cause.
• D. Incorrect. The Snowflake warehouse is used for data preprocessing, not for the SPCS inference service. Scaling the warehouse does not directly address inference performance issues.

Correct answer: B — Use a separate Snowflake account for retraining with its own budget.

• A. Incorrect. Increasing the budget limit indefinitely is not sustainable; it removes cost controls and does not isolate retraining workloads. This approach can lead to uncontrolled costs and does not address budget management best practices.
• B. Correct. Using a separate Snowflake account for retraining with its own budget provides workload isolation and independent budget management. This ensures retraining tasks are not impacted by budget limits in the primary account, aligning with best practices for critical automated pipelines.
• C. Incorrect. In Snowflake, budget enforcement is account-level and cannot be circumvented by resource groups. Resource groups are not designed to bypass governance controls, so this does not prevent suspension due to budget limits.
• D. Incorrect. While alerts are useful for monitoring, they do not prevent suspension. Manual override is reactive and not scalable for automated retraining pipelines, leaving them vulnerable to interruption when budget is exceeded.

Correct answer: A — Browser-based SSO

• A. Correct. Snowflake CLI defaults to browser-based SSO for local interactive use. When no authenticator is explicitly configured, the CLI initiates a browser-based login flow, which is the recommended approach for local development.
• B. Incorrect. OAuth with client credentials is typically used for service-to-service authentication in automated or non-interactive environments, not as the default for local machine use.
• C. Incorrect. Key pair authentication is a secure method but requires explicit configuration and is commonly used for automation and CI/CD pipelines, not as the default local authentication method.
• D. Incorrect. Username and password authentication is supported but is not the default for Snowflake CLI. The CLI favors more secure interactive methods such as browser-based SSO for local use.

Correct answer: A — snow procedure create -f <file>

• A. Correct. The `snow procedure create -f <file>` command is the dedicated Snowflake CLI command to create or replace a stored procedure from a file containing the procedure definition. This command is specifically designed for this purpose, making it the precise tool when you need to deploy a stored procedure from a file.
• B. Incorrect. While `snow sql -f <file>` can execute any SQL from a file, including a `CREATE OR REPLACE PROCEDURE` statement, it is a general SQL execution command and not specifically designed for creating or replacing stored procedures. The question asks for a command specifically designed for that task.
• C. Incorrect. `snow function create` is used for creating user-defined functions (UDFs), not stored procedures. It is a separate object type and command.
• D. Incorrect. `snow stage put` uploads files to a Snowflake stage. It can be part of a deployment workflow but does not create or replace stored procedures itself.

Correct answers: A, E — Tasks; Stored Procedures

• A. Correct. Tasks are Snowflake’s native scheduling and orchestration mechanism, enabling recurring execution of SQL statements, stored procedures, or other tasks to automate steps like feature refresh, model retraining, and inference.
• B. Incorrect. Snowpipe is designed for continuous data ingestion from files, not for orchestrating ML pipeline execution. While it can feed data into a pipeline, it does not automate model training or deployment steps.
• C. Incorrect. Streams track data changes (e.g., inserts, updates) and are useful as triggers for incremental processing, but they do not directly execute pipeline steps. They typically work with tasks or stored procedures to initiate downstream actions.
• D. Incorrect. External Functions allow Snowflake to call external services (e.g., cloud functions, APIs), which can be part of an ML solution, but they are not designed for scheduling or orchestrating pipeline execution.
• E. Correct. Stored procedures encapsulate pipeline logic such as data preprocessing, model training, evaluation, and deployment. They are frequently invoked by tasks to automate ML workflows, forming a core building block for pipeline automation.
• F. Incorrect. Sequences generate unique numeric values, typically for surrogate keys or identifiers. They have no role in automating ML pipeline execution and are unrelated to orchestration or workflow management.

Correct answer: D — Use key pair authentication with the private key stored as a GitHub Secret and passed via an environment variable

• A. Incorrect. OAuth device code flow is designed for interactive, user-driven authentication and is not supported by Snowflake CLI for non-interactive use. It would still require an interactive step, which is not feasible in a GitHub Actions workflow.
• B. Incorrect. While storing credentials as GitHub Secrets is better than hardcoding, passing username and password to `snow connection add` is not the preferred method for CI/CD. Key pair authentication is more secure and recommended for automated deployments.
• C. Incorrect. Browser-based SSO requires an interactive login, which cannot be automated in a headless CI/CD environment like GitHub Actions. It is not suitable for non-interactive pipelines.
• D. Correct. Key pair authentication is the recommended secure method for non-interactive automation with Snowflake CLI. The private key should be stored as a GitHub Secret and injected into the workflow via an environment variable (e.g., SNOWFLAKE_PRIVATE_KEY) or as a file, avoiding credentials in the repository.

Correct answers: A, B — Use `CREATE OR REPLACE` for all objects to avoid errors; Use conditional logic like `IF NOT EXISTS` where possible

• A. Using `CREATE OR REPLACE` is a common idempotent pattern for objects such as functions, procedures, and stages, ensuring scripts can be rerun without errors. However, it should be applied selectively, as it may overwrite existing objects and is not recommended for data-bearing tables.
• B. Conditional logic like `IF NOT EXISTS` prevents errors if objects already exist, making scripts safe to rerun. This is a standard practice for idempotent deployments.
• C. Dropping the database before recreating is destructive and not idempotent; it causes data loss and downtime, making it unsafe for repeated runs.
• D. While `--exit-on-error` improves error handling, it does not make scripts idempotent. It only controls execution on failure but does not ensure safe reruns.
• E. Overwriting staged files with `--overwrite` is idempotent for file deployment but does not address idempotency of database object creation, which is the focus of ML pipeline deployment.
• F. Storing scripts in a version-controlled Git repository is a CI/CD best practice for repeatability, but it does not directly ensure that a script is idempotent. It supports consistency but does not prevent errors on multiple runs.

Correct answer: A — Switch to a Large warehouse to reduce training time and minimize spilling, which may lower total credits.

• A. Correct. If the current Medium warehouse is causing spilling due to insufficient memory, switching to a Large warehouse can reduce spilling and shorten runtime. Although the per-second cost is higher, the overall reduction in runtime often leads to lower total credits consumed, making this a cost-effective optimization for memory-bound ML training.
• B. Incorrect. An X-Small warehouse has less memory, likely increasing spilling and extending runtime. Even though the per-second cost is lower, the longer execution time and potential spill-related overhead typically result in higher total credit consumption.
• C. Incorrect. Increasing MAX_CLUSTER_COUNT enables a multi-cluster warehouse for concurrency, but does not speed up a single ML training query. Each query still runs on a single cluster, so it does not address memory pressure or reduce spilling for this job.
• D. Incorrect. An Extra Large warehouse provides more memory and reduces spilling, but its per-second cost is substantially higher. For most ML workloads, the performance gain does not compensate for the increased cost, making it less efficient than a right-sized larger warehouse.

Correct answer: D — Tag-based constraint

• A. Incorrect. Resource monitors track and limit credit consumption for warehouses but do not provide cost attribution or granular tracking for ML workloads. They are used for budget enforcement, not cost allocation metadata.
• B. Incorrect. Notification integrations send alerts via external services (e.g., email, Slack) when events occur. They do not manage or attribute ML costs or support resource optimization.
• C. Incorrect. Warehouse policies govern warehouse usage patterns (e.g., auto-suspend, auto-resume) but are not the standard Snowflake feature for cost attribution. Object tagging and reporting on tag values handle cost allocation.
• D. Correct. Tag-based constraints apply policies or limits based on object tags, enabling categorization and tracking of ML workloads. Tags on warehouses, databases, schemas, and other objects support cost attribution, chargeback, and resource tracking.

Correct answer: A — AUTO_SUSPEND_SECS

• A. Correct. AUTO_SUSPEND_SECS is a valid Snowflake parameter that specifies the number of seconds a warehouse can be idle before it is automatically suspended, helping to reduce costs by stopping unused resources.
• B. Incorrect. IDLE_SHUTDOWN_TIMEOUT is not a valid Snowflake parameter for warehouse suspension or cost optimization. Snowflake uses AUTO_SUSPEND_SECS for this purpose.
• C. Incorrect. MAX_IDLE_TIME is not a recognized Snowflake parameter for managing warehouse suspension or resource optimization. The correct parameter is AUTO_SUSPEND_SECS.
• D. Incorrect. SUSPEND_AFTER_IDLE is not a valid Snowflake parameter; the correct parameter is AUTO_SUSPEND_SECS.

Correct answers: A, B, E — Configure auto-suspend with a short idle timeout so nodes stop quickly after finishing work.; Create separate pools: a small dedicated pool for inference and a larger auto-suspending pool for training.; Set up a queue that automatically launches and terminates nodes for batch training runs during off-hours.

• A. Configuring auto-suspend with a short idle timeout helps prevent paying for unused compute after work completes, ensuring resources are released quickly and reducing unnecessary costs from idle nodes.
• B. Creating separate pools allows better resource allocation: a small dedicated pool for inference ensures low-latency responses, while a larger auto-suspending pool for training optimizes cost by scaling down when not in use.
• C. Increasing node count to handle all workloads simultaneously and then manually reducing it is inefficient. Manual scaling is error-prone and can lead to over-provisioning or underutilization, increasing costs.
• D. Using a single large GPU instance to run all jobs sequentially may reduce idle time between jobs but is inefficient for parallel workloads. It can lead to underutilization of expensive GPU capacity and higher costs due to lack of scalability.
• E. Setting up a queue that automatically launches and terminates nodes for batch training runs during off-hours supports elastic scale-up and scale-down aligned to actual demand, ensuring resources are only used when needed, optimizing cost and efficiency.

Correct answer: D — WAREHOUSE_TAGS('<warehouse_name>')

• A. Incorrect. TAG_REFERENCES is used to list all objects that reference a specific tag, not to retrieve tags directly assigned to a warehouse. It is useful for impact analysis, not for directly viewing the warehouse's assigned tags.
• B. Incorrect. TABLE_PRIVILEGES retrieves privileges on tables and does not return tag information for warehouses. It is not the correct function for viewing tags assigned to a warehouse.
• C. Incorrect. OBJECT_TAGS retrieves tags for objects like tables or views, but Snowflake does not use OBJECT_TAGS for warehouse objects specifically. The correct function for warehouses is WAREHOUSE_TAGS.
• D. Correct. WAREHOUSE_TAGS('<warehouse_name>') is the Snowflake function specifically designed to retrieve the tags assigned directly to a warehouse. It returns tag information for the specified warehouse, aiding in cost attribution and resource optimization.

Correct answer: B — Implement a row access policy using a mapping table to filter rows based on the current role's region.

• A. Incorrect. Creating a materialized view per role is static and does not dynamically filter data based on the user's session context. This approach is unscalable, creates duplicated objects, and does not provide centralized policy enforcement, making it unsuitable for row-level security.
• B. Correct. Row access policies in Snowflake are purpose-built for row-level security. They dynamically filter rows based on session context (e.g., current role) by referencing a mapping table that assigns regions to roles. This cleanly enforces security without manual view creation or additional logic.
• C. Incorrect. Dynamic data masking hides or obfuscates column values but does not filter rows. It is appropriate for protecting sensitive column data, not for enforcing row-level access restrictions based on geography.
• D. Incorrect. While a secure view can encapsulate filtering logic, it is less flexible and maintainable than a row access policy. The security logic lives in the view definition rather than a dedicated policy, and it does not dynamically adapt to the user's role without additional complexity. Row access policies are the recommended approach.

Correct answer: B — A SQL function that returns a string value

• A. Incorrect. While a SQL function returning a boolean is used for row access policies, the question likely pertains to masking policies, which require a function returning a value of the column's data type (commonly a string). This option alone does not cover the typical masking policy implementation.
• B. Correct. Masking policies in Snowflake are implemented using SQL functions that return a value, often a string, to replace the original column value. This matches the required signature for defining such security policies.
• C. Incorrect. A stored procedure executes procedural logic and is not used to define or attach security policies. Policies must be implemented with SQL functions, not procedures.
• D. Incorrect. A view can provide filtered or transformed data but is not a security policy mechanism. Views complement governance but do not enforce masking or row-level access policies directly.

Correct answer: C — Grant OPERATE on the compute pool

• A. Incorrect. USAGE on a compute pool allows a role to reference and use the pool for queries, but it does not grant the ability to start or stop the pool.
• B. Incorrect. MODIFY on a compute pool allows altering its configuration (e.g., size, auto-suspend), but not starting or stopping the pool.
• C. Correct. OPERATE on a compute pool is required to start, stop, or resume the pool. It also allows resizing the pool.
• D. Incorrect. MONITOR on a compute pool provides read-only visibility into status and usage metrics, but does not permit starting or stopping.

Correct answer: B — Apply a dynamic data masking policy on diagnosis that maps values based on role.

• A. Incorrect. Creating a view does not provide centralized, policy-driven column-level protection; it is static and does not adjust dynamically based on user roles. Native policies like dynamic data masking are more secure and consistent.
• B. Correct. Dynamic data masking is the appropriate Snowflake feature to control sensitive column values based on role, allowing authorized users to see unmasked values while others see masked or transformed values, without changing underlying data.
• C. Incorrect. Creating a separate anonymized copy introduces data duplication and maintenance overhead and does not enforce real-time role-based access control. It is not a Snowflake security policy.
• D. Incorrect. Row access policies restrict which rows a role can see, not the values within a column. For column-level sensitivity like diagnosis, a column-level policy (e.g., dynamic data masking) is needed.