Free Snowflake SnowPro Specialty: Gen AI (GES-C02) Sample Questions

Correct answers: A, B, C — Custom instructions can guide SQL generation behavior using natural-language guidance embedded in the semantic model; Custom instructions can be used to block or redirect questions about specific restricted topics via question categorization; Custom instructions support separate, more structured guidance for different parts of the Analyst workflow through modular components

• A. Custom instructions let administrators write natural-language guidance that steers how Cortex Analyst generates SQL for a given semantic model.
• B. The question categorization component of custom instructions is specifically designed to block or redirect questions on restricted topics.
• C. Custom instructions support modular, structured components covering different parts of the workflow, such as SQL generation and question categorization, rather than a single flat instruction blob.
• D. This is incorrect; custom instructions supplement the semantic model's tables, facts, and dimensions rather than replacing the need to define them.
• E. This is incorrect; custom instructions are configured within a given semantic model's YAML, so they are scoped per model rather than being account-wide only.

Correct answer: A — Call the endpoint with the default streaming behavior, which sends the response as server-sent events

• A. By default the agent:run API streams the response as server-sent events, which is exactly how an application can display output token-by-token as it is generated.
• B. Setting stream to false disables streaming and returns a single consolidated JSON response instead of incremental tokens, which is the opposite of what is needed here.
• C. Manually polling a status endpoint is unnecessary and slower than using the API's built-in streaming mode for incremental output.
• D. DATA_AGENT_RUN returns a non-streaming JSON response and does not provide token-by-token output; the REST API's streaming mode is the appropriate choice instead.

Correct answer: A — Cortex Analyst handles text-to-SQL over structured semantic views, Cortex Search handles retrieval over unstructured content, and Cortex Agents orchestrate both as tools within a single reasoning workflow

• A. This correctly separates the three capabilities: Cortex Analyst for structured text-to-SQL, Cortex Search for unstructured retrieval, and Cortex Agents for orchestrating both together.
• B. These are three distinct products with different purposes, not interchangeable names for one service.
• C. This reverses the actual roles; Cortex Analyst performs text-to-SQL generation, and Cortex Search performs document and content retrieval.
• D. Cortex Agents are designed to orchestrate tools like Cortex Analyst and Cortex Search across structured and unstructured data, not restricted to numeric forecasting.

Correct answer: A — Change the model name argument passed to AI_COMPLETE to reference an available catalog model

• A. This is correct: catalog models such as Claude, Llama, and Mistral are called serverlessly by simply swapping the model name argument, with no separate deployment needed.
• B. This is incorrect: registering a custom model class is for bringing in externally trained models, not for switching between already-available catalog LLMs.
• C. This is incorrect: retraining weights is unnecessary and far more effortful than simply pointing the function call at a different catalog model.
• D. This is incorrect: provisioning dedicated GPU compute is unnecessary since catalog LLMs are already served in a fully managed, serverless way.

Correct answer: D — Snowflake Intelligence, a configured conversational layer built on top of Cortex Agents

• A. This is incorrect: adapting model weights is a training activity and does not provide an end-user-facing, configuration-driven chatbot interface.
• B. This is incorrect: containerized model hosting addresses infrastructure for custom models, not a business-user-facing conversational interface.
• C. This is incorrect: a terminal-based coding assistant targets engineers writing code, not business employees asking conversational questions.
• D. This is correct: this product delivers a configurable, no-code chatbot experience by packaging the orchestration already provided by Cortex Agents for end users.

Correct answer: A — It presents users with example prompts drawn from the semantic model so they can discover what kinds of questions the system can answer

• A. Suggested Questions surfaces example natural-language prompts based on the semantic model, helping new users understand the scope of questions the interface can handle and accelerating adoption.
• B. Suggested Questions is about presenting example prompts to users, not about automatically running queries without any user-initiated question or confirmation.
• C. Ranking by cosine similarity is a vector search operation used in retrieval, unrelated to the onboarding purpose of showing example questions in a chat interface.
• D. Access control over the semantic view is handled through RBAC and grants, not through the Suggested Questions feature, which is purely about surfacing example prompts.

Correct answers: A, B, C, D — Generating SQL from natural-language questions grounded in a semantic model; Referencing a Verified Query Repository of vetted question-to-SQL examples; Applying CUSTOM_INSTRUCTIONS to steer generated SQL toward organizational conventions; Integrating with Cortex Search to answer questions that span structured and unstructured data

• A. Text-to-SQL generation grounded in a semantic model is the core capability of Cortex Analyst, translating natural-language business questions into accurate SQL.
• B. The Verified Query Repository is a documented feature that lets Cortex Analyst reference curated, validated question-to-SQL examples to improve accuracy on recurring questions.
• C. CUSTOM_INSTRUCTIONS lets administrators supply standing guidance that shapes how Cortex Analyst interprets questions and writes SQL, matching organizational conventions.
• D. Cortex Analyst can be combined with Cortex Search so a single interface answers both structured, SQL-answerable questions and unstructured, document-grounded questions.
• E. Cortex Analyst answers questions against existing tables and semantic models; it has no documented capability to automatically drop or delete underlying tables.
• F. Query execution time still depends on warehouse sizing and query complexity; Cortex Analyst does not guarantee zero latency regardless of the compute resources involved.

Correct answer: A — One aggregated insight string is returned per product_id group, synthesized across all rows in that group even beyond a single context window

• A. This is correct: this aggregate function synthesizes an instruction-driven insight across every row in a group, and it explicitly supports datasets larger than the model's context window.
• B. This is incorrect: aggregate behavior with GROUP BY is a core supported use case for this function, not a failure condition.
• C. This is incorrect: this function is an aggregate, so it collapses many rows into one output per group rather than returning a value per input row.
• D. This is incorrect: the natural-language instruction argument directly controls what insight is generated; it is not ignored.

Correct answers: A, B, C, D — VECTOR_COSINE_SIMILARITY, for angular similarity between two vectors; VECTOR_L2_DISTANCE, for Euclidean distance between two vectors; VECTOR_INNER_PRODUCT, for a magnitude-weighted dot product between two vectors; VECTOR_L1_DISTANCE, for Manhattan distance between two vectors

• A. This is correct: this function measures angular closeness between two vectors, which is a real, documented vector similarity function commonly used with text embeddings.
• B. This is correct: this function computes Euclidean straight-line distance between two vectors and is a real documented distance function.
• C. This is correct: this function computes the dot product between two vectors, factoring in both direction and magnitude, and is a real documented vector function.
• D. This is correct: this function computes Manhattan (sum of absolute differences) distance and is a real documented vector function, often faster than Euclidean distance at high dimensions.
• E. This is incorrect: there is no vector-native classification function under this name; category assignment on text or images is handled by the AI_CLASSIFY function instead.
• F. This is incorrect: there is no function that converts a vector produced by one embedding model into another model's vector space; re-embedding the source input is required instead.

Correct answers: A, B, D — AI_SENTIMENT is row-level, returning one sentiment result for each input text; AI_CLASSIFY is row-level, returning one classification result for each input text; AI_AGG is an aggregate function that collapses many rows into one instruction-driven output per group

• A. This is correct: sentiment extraction evaluates one input text and returns one sentiment result for it, with no aggregation across rows involved.
• B. This is correct: classification evaluates one input at a time and returns category labels for that single input, making it a row-level operation.
• C. This is incorrect: this function is an aggregate that synthesizes a summary across every row in a group, it does not return a separate summary per individual row.
• D. This is correct: this function is documented as an aggregate that combines many rows into a single instruction-driven output per group, similar in spirit to GROUP BY aggregates.
• E. This is incorrect: translation operates on one text value at a time and has no aggregate behavior or GROUP BY requirement.
• F. This is incorrect: PII redaction operates on one text value at a time and returns scrubbed text or detection spans for that single input, it does not merge findings across rows.

Correct answer: A — SNOWFLAKE.CORTEX_ANALYST_USER

• A. This database role is scoped specifically to Cortex Analyst usage, so granting it gives a caller exactly the access needed without extending broader Cortex privileges.
• B. This is a general administrative role for managing database objects; it does not inherently grant the ability to call Cortex Analyst.
• C. This role has global account privileges, which is far broader than necessary and violates least-privilege design for a chat-with-data feature.
• D. This role grants access to Cortex functions more broadly than Analyst alone, so it is not the narrowest role available for this specific need.

Correct answers: B, D, E — Planning; Tool execution; Reflection

• A. Fine-tuning adjusts model weights ahead of time and is not a runtime step an agent performs while handling an individual request.
• B. The agent first analyzes the request, disambiguates it if needed, and decides which tools to call, which is the planning stage of the loop.
• C. Training a model is a separate offline process unrelated to how an already-configured agent handles an incoming request.
• D. After planning, the agent calls the selected tools, such as Cortex Analyst or Cortex Search, to gather the information needed to answer.
• E. The agent evaluates the results returned by its tools to decide whether to clarify, call further tools, or produce a final response, which is the reflection stage.

Correct answer: A — A dynamic table that calls AI_EMBED on the passage column and stores the result in a VECTOR-typed column, refreshed incrementally as new chunks arrive

• A. A dynamic table computing AI_EMBED into a VECTOR column can incrementally refresh only for new or changed base rows, keeping the embedding index current without full recomputation.
• B. A one-time batch job does not automatically pick up newly added articles, and VARIANT is not the appropriate storage type for embeddings meant to support vector similarity search.
• C. AI_TRANSLATE changes the language of text, it does not generate or maintain embeddings for retrieval.
• D. Running AI_SIMILARITY against every existing passage for each new chunk computes pairwise comparisons rather than building or maintaining an embedding index, and does not scale as the corpus grows.

Correct answer: A — Apply AI_TRANSLATE to normalize ticket text into English first, then run AI_CLASSIFY and any keyword-based rules against the translated text

• A. Normalizing the language up front ensures the classification model and keyword rules, which were validated against English text, operate on text in the language they were designed for, giving consistent results across all tickets.
• B. Classifying non-English text with a model and rules tuned for English is likely to be unreliable, and translating only the resulting label afterward does not fix inaccurate classification of the original content.
• C. AI_CLASSIFY does not natively expose a low-confidence signal to gate translation, and language mismatch itself is likely a root cause of unreliable classification, not just a subset needing extra handling.
• D. Running keyword rules first on untranslated text means those rules, built for English, are applied to text they were never designed to match, producing unreliable results before any translation occurs.

Correct answers: C, D — block; stage

• A. local volumes provide ephemeral storage shared between containers within the same service instance and do not persist once that instance is gone.
• B. memory volumes are RAM-backed scratch space that disappears when the container stops, so they do not persist data beyond the instance.
• C. block volumes provide persistent storage that survives service restarts, making them suited for stateful workloads that must retain data.
• D. stage volumes expose the contents of a Snowflake stage, which is durable storage outside the service instance, so data written there persists independently of the container's lifecycle.
• E. warehouse is not a valid volume type at all; virtual warehouses provide SQL compute and have no relationship to container storage mounts.

Correct answer: A — Push the image to a Snowflake image repository, create a compute pool, and define a service specification exposing port 8080 as an endpoint

• A. Since the model ships only as a container with an internal REST port, the correct path is Snowpark Container Services: push to an image repository, provision a compute pool, and expose the port through the specification's endpoints so the service can be called.
• B. log_model serializes Python model objects; it cannot register an opaque Docker image that has no corresponding Python object to serialize.
• C. AI_COMPLETE calls Snowflake-hosted large language models by name and cannot execute an arbitrary uploaded container image.
• D. Virtual warehouses run SQL and Snowpark compute but cannot host an arbitrary containerized REST service regardless of sizing.

Correct answer: A — Load the MLflow pyfunc model in Python and pass it to log_model

• A. Because MLflow pyfunc models are natively supported by log_model, loading the existing pyfunc object and passing it directly to log_model registers it without retraining.
• B. Manually exporting to a Docker image and building compute pool infrastructure is unnecessary extra work when native MLflow support already exists in the registry.
• C. Retraining from scratch discards the existing MLflow-tracked model entirely and is not required since native import support exists.
• D. Converting to a SQL UDF is not a supported or necessary step for bringing an MLflow pyfunc model into the Model Registry.

Correct answers: A, B, C — CORTEX_USER is granted to PUBLIC by default, while AI_FUNCTIONS_USER is not; AI_FUNCTIONS_USER only covers scalar Cortex functions and excludes aggregate functions such as AI_AGG; CORTEX_USER grants broader access across Cortex AI functions than AI_FUNCTIONS_USER

• A. CORTEX_USER is granted to PUBLIC by default so that most Cortex functions work out of the box, whereas AI_FUNCTIONS_USER is not granted to PUBLIC and must be explicitly assigned.
• B. AI_FUNCTIONS_USER is scoped to scalar functions and specifically excludes aggregate-style functions like AI_AGG and AI_SUMMARIZE_AGG, unlike the broader CORTEX_USER role.
• C. CORTEX_USER grants access to the full set of Cortex AI functions, making it broader in scope than the more limited AI_FUNCTIONS_USER role.
• D. Setting the CORTEX_MODELS_ALLOWLIST parameter requires the ACCOUNTADMIN role and ALTER ACCOUNT privileges; it has no relationship to holding the AI_FUNCTIONS_USER database role.
• E. CORTEX_USER can be granted to any role, and in fact is granted to PUBLIC by default, so it is not restricted to ACCOUNTADMIN.

Correct answers: A, B, C — Grounding responses in retrieved, relevant source documents through Cortex Search; Measuring output quality with groundedness and correctness metrics via AI Observability; Applying prompt engineering techniques such as instructing the model to answer only from provided context

• A. Retrieval-augmented generation anchors model responses in actual source documents, substantially reducing the model's tendency to fabricate unsupported claims.
• B. AI Observability computes groundedness and correctness metrics using an LLM-as-judge approach, giving teams a way to detect and iterate away from hallucinated or biased outputs.
• C. Explicit prompt instructions that constrain the model to answer only using supplied context are a well-established technique for reducing fabrication.
• D. Maximizing temperature increases output randomness and creative variation, which tends to worsen rather than reduce hallucination.
• E. Broadening model access controls is a governance concern unrelated to output quality and does nothing to reduce hallucination or bias in generated responses.

Correct answer: A — Keep the account allowlist restricted to the approved list for the contractor role's default access, and additionally grant the analytics role the specific per-model application role for the preview model

• A. Because RBAC is checked before the allowlist, granting the analytics role the specific model's application role lets it reach the preview model even though the allowlist otherwise restricts the account to the approved list used for the contractor.
• B. Opening the allowlist to 'All' would let the contractor role reach every model, directly violating the requirement to restrict the contractor to a short approved list.
• C. Blocking everything with no RBAC grants would also prevent the analytics role from reaching the preview model, failing the second requirement entirely.
• D. Granting CORTEX_USER to the contractor while withholding it from the analytics role reverses the intended access and does not grant the preview model access the analytics team needs.

Correct answer: A — Selecting the smallest model that produces acceptable summary quality rather than defaulting to the largest available model

• A. Since per-token pricing varies significantly by model size, choosing the smallest model that still meets quality needs directly reduces the credit rate applied to every token processed.
• B. Defaulting to the largest model regardless of task complexity maximizes the per-token rate paid even when a cheaper model would suffice, increasing cost unnecessarily.
• C. Running every model against the same prompt multiplies token consumption across all of them, which increases total cost rather than reducing it.
• D. Adding more few-shot examples increases input token count on every call, raising cost rather than lowering it, especially when the added examples are not needed for the task.

Correct answer: A — Run the COUNT_TOKENS function against the prompt text to estimate token volume before invoking the generative function

• A. COUNT_TOKENS reports token counts for given text without invoking the model itself, letting the engineer estimate cost ahead of running the actual generative workload.
• B. Running the function on even a single row still incurs an actual inference charge, which is exactly the cost the engineer is trying to estimate without incurring first.
• C. CORTEX_ANALYST_USAGE_HISTORY tracks Cortex Analyst requests, not AI_COMPLETE token usage, so it would not provide a relevant estimate for this workload.
• D. Token count depends on text length and content, not row count, since a single row can contain many tokens; row count alone is not a valid proxy for token volume.

Correct answer: A — SNOWFLAKE.CORTEX_AGENT_USER

• A. This is correct: calling a Cortex Agent is authorized by holding either CORTEX_USER or this agent-scoped role, which was purpose-built for that use case.
• B. This is incorrect: this role is scoped to Cortex Analyst requests and is not documented as sufficient for calling an agent by itself.
• C. This is incorrect: this role only covers embedding functions and managed search embeddings, unrelated to agent invocation.
• D. This is incorrect: this role covers scalar AI functions but explicitly excludes Cortex services such as Agents.

Correct answer: A — Call SNOWFLAKE.MODELS.CORTEX_BASE_MODELS_REFRESH() so model objects and their application roles are populated

• A. This is correct: the model objects in SNOWFLAKE.MODELS and their corresponding application roles must be populated via this refresh call before any model-specific role can be granted.
• B. This is incorrect: disabling the allowlist before RBAC grants are in place would leave users with fully-qualified model calls unable to fall back, so the refresh and grant steps must happen first, in that order.
• C. This is incorrect: the SNOWFLAKE.MODELS schema is system-managed and populated by the refresh procedure, not something an administrator manually drops or recreates.
• D. This is incorrect: this broad database-level privilege is not the documented prerequisite for enabling model-specific RBAC; the refresh procedure is what populates the grantable roles.

Correct answer: A — It marks the overall input and output of a single application invocation, anchoring record-level metrics such as answer relevance and correctness

• A. RECORD_ROOT designates the top-level call whose input and output represent the whole record, which is where record-level metrics like answer relevance and correctness attach.
• B. Retrieval functions are tagged with the RETRIEVAL span type, not RECORD_ROOT, so that context relevance can be computed against the retrieved chunks specifically.
• C. Generation functions are tagged with the GENERATION span type; RECORD_ROOT is not limited to token or latency capture and covers the whole record instead.
• D. Writing to the event table is an internal platform mechanism, not something a developer tags with a span type, and RECORD_ROOT has no connection to storage cost attribution.

Correct answer: A — External Agent objects share a namespace with model objects in the schema, so their names cannot collide

• A. External Agent objects share a namespace with model objects within a schema, so an existing model object with the same name will block creation of an External Agent using that name.
• B. External Agents are created in the developer's own schema, not restricted to the SNOWFLAKE system database, so that is not the source of this naming conflict.
• C. Creating an External Agent does not require the CREATE MODEL privilege or draw from a model quota; the conflict here is purely a duplicate-name issue in a shared namespace.
• D. External Agent names have no required relationship to Cortex Search service names, so a missing search service is not what is causing this registration failure.

Correct answer: A — Iterate the response's pages array and reference each element's content field alongside its zero-based index field

• A. When page_split is TRUE, the response contains a pages array whose elements each expose a content field and an index field identifying that page's position.
• B. There is no single combined content field once page_split is enabled, and pageCount is not a mechanism for splitting text by newlines.
• C. The images array holds extracted picture content when extract_images is enabled; page-level text is never rerouted into image objects.
• D. The metadata field is tied to setting return_error_details to TRUE, not to page_split, so its availability does not depend on page splitting.

Correct answer: A — 2,000 pages

• A. The April 2026 platform update raised AI_PARSE_DOCUMENT's supported page count to 2,000 pages for both OCR and LAYOUT modes.
• B. 500 pages understates the current documented limit after the April 2026 increase, which raised the ceiling well beyond that figure.
• C. 300 pages reflects an earlier, lower ceiling and is no longer accurate after the documented April 2026 page-limit increase.
• D. AI_PARSE_DOCUMENT does enforce a documented maximum page count per call in addition to any token-related constraints on output size.

Correct answer: A — Load the files into a stage, then reference them via TO_FILE()

• A. Both functions operate on FILE objects created from documents sitting in an internal or external stage, and TO_FILE() is the mechanism used to reference a staged document in the call.
• B. Storing raw bytes in a VARIANT column bypasses the stage-based FILE reference these functions expect, so it is not a supported input path.
• C. A Snowpark DataFrame represents tabular query results, not a staged document reference, so it cannot substitute for a FILE object built from a stage.
• D. The model registry stores machine learning models and artifacts, not source documents awaiting parsing or extraction, so it is unrelated to this requirement.

Correct answer: A — It fails, since a single call allows at most 100 entity questions and 10 table questions

• A. AI_EXTRACT limits a single call to at most 100 entity extraction questions and 10 table extraction questions, so requesting 120 entities and 12 tables exceeds both caps and the call fails.
• B. The function does enforce documented per-call caps on both entity and table questions, so there is no unlimited-question behavior to rely on here.
• C. The actual documented caps are 100 entity questions and 10 table questions per call, not the lower thresholds stated here.
• D. Exceeding the documented caps produces a failure rather than a silent truncation of the request down to the allowed limits.

Correct answer: A — SUSPEND_TASK_AFTER_NUM_FAILURES set to a small integer so the task automatically suspends after that many consecutive failed runs

• A. SUSPEND_TASK_AFTER_NUM_FAILURES automatically suspends a task once it has failed the configured number of consecutive times, preventing it from continuing to fire and fail indefinitely until an operator investigates and resumes it.
• B. Disabling the timeout would let a stuck run consume compute indefinitely instead of failing fast; it does nothing to stop future scheduled runs after repeated failures.
• C. TARGET_COMPLETION_INTERVAL relates to serverless task compute sizing goals, not to suspending a task after repeated failures.
• D. SYSTEM$STREAM_HAS_DATA checks for unconsumed stream records, not for a task's own failure history, so it cannot be used to detect or react to consecutive run failures.

Correct answers: A, B, C — A SCHEDULE expression, using either a fixed interval or a cron pattern, that runs the task on a recurring cadence; An AFTER clause that positions the task as a child of a predecessor task within a task graph; A WHEN clause using SYSTEM$STREAM_HAS_DATA so the task only executes its body when the referenced stream has unconsumed records

• A. SCHEDULE accepts either a fixed interval like '5 MINUTE' or a cron-style expression, both of which are standard, documented ways to run a standalone task on a recurring cadence.
• B. AFTER defines a task's position in a task graph as a child of one or more predecessor tasks, causing it to run once its predecessors complete rather than on its own independent schedule.
• C. SYSTEM$STREAM_HAS_DATA is commonly used in a task's WHEN clause to conditionally skip execution when the associated stream has no new change records, avoiding wasted runs.
• D. Changing table ownership is an access-control operation and has no relationship to task scheduling or triggering; it does not cause any task to fire.
• E. Task comments are free-text metadata for documentation purposes only; Snowflake does not parse them for scheduling keywords or derive execution timing from them.

Correct answer: A — The EXECUTE TASK privilege on the account, or ownership of the task combined with the appropriate operate privilege

• A. Executing or resuming a task requires the EXECUTE TASK privilege (typically granted at the account level to the role that manages the task) along with sufficient ownership or operate rights on the task object itself; this is separate from privileges needed to call Cortex functions.
• B. CORTEX_USER governs access to Cortex AI functions like AI_COMPLETE or AI_PARSE_DOCUMENT; it does not grant the ability to execute or resume a task, which is a distinct object-level operation.
• C. USE AI FUNCTIONS gates access to AI/Cortex functions, not task execution; a role could hold this privilege and still be unable to run or resume a task without EXECUTE TASK.
• D. MONITOR on a warehouse allows viewing warehouse usage and status, but it does not grant the ability to execute or resume a task; that requires the task-specific EXECUTE TASK privilege.

Correct answer: A — The extracted table response has hit the function's per-call output token limit, so the table should be split by columns or pages into smaller extraction calls

• A. Table extraction responses are limited to a maximum output length in tokens, so a dense table can exceed that limit and appear truncated. Splitting the table by columns or across pages into smaller extraction calls keeps each response within the limit.
• B. Server-side encryption affects whether Snowflake can read the file at all, not how much of a table gets returned once extraction succeeds. A missing-encryption issue would block extraction entirely rather than produce a partially truncated table.
• C. AI_EXTRACT is not restricted to single-page documents, and multi-page documents are a normal, supported input. Re-paginating into single pages is not the documented cause of or fix for output truncation.
• D. A compound question phrasing affects clarity of the extracted values, not the number of table rows a response can contain. Row-count truncation in this scenario is driven by the output length limit, not by question structure.

Correct answers: A, B, C — The SNOWFLAKE.CORTEX_USER database role, granted by a role with ACCOUNTADMIN; CREATE MODEL privilege on the schema that will hold the fine-tuned model, plus USAGE on the containing database and schema; READ or OWNERSHIP privilege on the stage that stores the training documents

• A. The SNOWFLAKE.CORTEX_USER database role gates access to Cortex functions including fine-tuning, and this grant is made through a role holding ACCOUNTADMIN. Without it, the fine-tuning job cannot be initiated at all.
• B. Creating a model object requires the CREATE MODEL privilege on the target schema, along with USAGE on the database and schema so the role can operate within that namespace. Both are part of the documented privilege set for this workflow.
• C. The training documents live on a stage, and the role running the fine-tuning job needs READ or OWNERSHIP on that stage to access them. Without this, the job cannot read the files referenced by the training dataset.
• D. GLOBALADMIN is not a standard Snowflake system role and is not part of the documented privilege requirements for fine-tuning. This option describes a role that does not fit the actual access model.
• E. SECURITYADMIN is focused on managing grants and users at the account level and is not a documented requirement for running a fine-tuning job. Granting it directly to a service account is unrelated to the actual privilege checklist.
• F. Fine-tuning is performed within a single Snowflake account's objects and does not require organization-level ORGADMIN privileges. This option overstates the scope of access actually needed.