Free Databricks Generative AI Engineer Associate Practice Questions: Design Applications

Topic snapshot

Sample questions

These are original IT Mastery practice questions aligned to this topic area. They are not official Databricks questions, copied live-exam content, or exam dumps. Use them to preview question style and explanation depth before continuing with topic drills, mixed sets, and timed mocks in IT Mastery.

Question 1

Topic: Design Applications

A team is designing a Databricks RAG assistant for support engineers. Current runbooks are stored in a governed Delta table and already indexed in Mosaic AI Vector Search. The assistant must fetch relevant runbook passages before the model writes an answer.

User question
  -> Stage 1: rewrite/normalize question
  -> Stage 2: [missing component]
  -> Stage 3: build prompt with returned context
  -> Stage 4: Foundation Model API generates response

Which component should fill Stage 2?

Options:

• A. MLflow model signature validator

• B. Output parser for the final response

• C. Vector Search retriever for the runbook index

• D. Chat model serving endpoint

Best answer: C

Explanation: In a RAG chain, the knowledge-gathering step is retrieval. The retriever queries an external knowledge source, such as a Mosaic AI Vector Search index built from governed Delta tables, and returns relevant chunks or passages. Those passages are then inserted into the prompt so the Foundation Model API can generate an answer grounded in current source content. A model endpoint generates text, while validators and output parsers shape or check inputs and outputs; they do not retrieve external knowledge before generation.

• Signature validation helps enforce expected request and response structure, but it does not fetch runbook content.
• Output parsing formats the model’s completed answer, so it happens after generation rather than before it.
• Chat model serving provides the generative model, but the model should receive retrieved context from a separate retrieval step.

Question 2

Topic: Design Applications

An HR team wants an internal assistant that answers employee questions using governed policy PDFs stored in Unity Catalog. The assistant must cite source passages, respect existing access controls, and be delivered with minimal custom orchestration. It does not need to update HR systems or coordinate multiple specialized tools. Which engineering decision BEST satisfies these constraints?

Options:

• A. Use Multiagent Supervisor to coordinate HR action agents

• B. Build a custom Agent Framework planner with HR specialist agents

• C. Use Agent Bricks Information Extraction for all policies

• D. Use Agent Bricks Knowledge Assistant for the policy corpus

Best answer: D

Explanation: Agent Bricks should be preferred when a prebuilt capability directly matches the application’s task boundary. This scenario is document-grounded Q&A with citations over governed content, no external actions, no complex task routing, and a speed/maintenance constraint. Knowledge Assistant is designed for this pattern, so using it preserves governance and reduces custom code. Custom Agent Framework orchestration or a Multiagent Supervisor is more appropriate when the app must coordinate specialized agents, call tools, take actions, or manage branching workflows. Information Extraction fits structured field extraction from documents, not an interactive policy Q&A assistant. The key is to choose the smallest prebuilt capability that satisfies the user need.

• Custom orchestration overfits because no planner, tool action, or specialized-agent handoff is required.
• Information Extraction targets structured outputs from documents, not employee Q&A with citations.
• Multiagent Supervisor is unnecessary because the scenario does not require coordinating multiple agents or actions.

Question 3

Topic: Design Applications

A retail company is building a Databricks GenAI app for support agents who ask, “Should this return be approved, and why?” The app must use the latest return-policy PDFs in Unity Catalog, current order and return rows in Delta tables, cite the policy paragraph used, and avoid sending payment-card fields to the LLM. Which design is the best engineering decision?

Options:

• A. Use one Foundation Model API call with the agent’s question.

• B. Use a multi-agent supervisor with separate specialist agents.

• C. Use one fine-tuned model trained on historical return decisions.

• D. Use a pipeline: retrieve policy, query masked order fields, apply rules, then draft.

Best answer: D

Explanation: The requested outcome is not just text generation. It combines current document retrieval, governed tabular lookup, deterministic business logic, citation, and controlled generation. A direct Foundation Model API call can draft language, but it cannot reliably fetch the latest policy PDFs, read current Delta rows, perform repeatable eligibility checks, cite the exact paragraph, and exclude payment-card fields unless those steps are orchestrated outside the model. In Databricks, this points to a pipeline: retrieve relevant policy chunks, query only approved Unity Catalog or Delta columns, compute eligibility with code or rules, then pass a compact fact bundle and citations to the LLM for the final explanation. The LLM is one component in the application, not the whole application.

• Direct model call fails because the model would not have reliable access to current governed tables, source citations, or deterministic return logic.
• Fine-tuning only may learn historical patterns, but it does not solve current policy retrieval, live order lookup, or citation requirements.
• Multi-agent supervisor overbuilds the solution because the task has a fixed retrieval, lookup, rule, and generation flow.

Question 4

Topic: Design Applications

A team is implementing a Databricks RAG chain for HR policy Q&A. The app must look up policy passages in Mosaic AI Vector Search, include them in the LLM instructions, call a Model Serving endpoint, parse a JSON answer with citations, and attach request metadata before returning to the UI. Which chain design assigns these tasks to the correct components?

Options:

• A. Retriever queries Vector Search; prompt template inserts passages; model endpoint generates; parser reads JSON; post-processing adds metadata.

• B. Retriever builds the final prompt; parser calls Model Serving; post-processing extracts JSON; prompt template adds request metadata.

• C. Model endpoint retrieves passages directly; retriever parses citations; prompt template deduplicates metadata; post-processing writes instructions.

• D. Prompt template queries Vector Search; model endpoint formats citations; parser adds metadata; post-processing retrieves missed passages.

Best answer: A

Explanation: A RAG chain separates responsibilities by stage. The retriever uses the user query to fetch relevant chunks from Vector Search. Prompt construction then combines the user question, retrieved context, and formatting instructions. Model invocation sends that completed prompt to the Model Serving endpoint or Foundation Model API. Response parsing converts the model output into the expected structure, such as JSON fields and citations. Post-processing handles deterministic application logic after parsing, such as adding request metadata, normalizing output, or removing duplicates. Keeping these boundaries clear makes the chain easier to evaluate, trace, and modify.

• Prompt retrieval confusion fails because a prompt template should assemble inputs, not execute the Vector Search lookup.
• Parser invocation confusion fails because response parsers interpret model output; they do not call the serving endpoint.
• Model does everything fails because retrieval, parsing, and deterministic metadata handling should remain explicit chain stages, not hidden inside generation.

Question 5

Topic: Design Applications

A support operations team is building a Databricks GenAI pipeline to triage warranty claims. The pipeline retrieves policy clauses from Unity Catalog Delta tables through Vector Search and is served behind a workflow that can only route claims using predefined fields. Reviewers need source-backed decisions and a way to send uncertain cases to humans. Which output design is the best engineering decision?

Options:

• A. A conversational answer with follow-up questions for the reviewer

• B. Structured JSON with decision, rationale, citations, confidence, and review flag

• C. The raw retrieved chunks and similarity scores

• D. A free-form summary of the retrieved policy clauses

Best answer: B

Explanation: When a use case requires a decision-ready result, the pipeline output should match the downstream decision interface, not merely expose text. Here, the workflow needs predefined fields to route claims, and reviewers need evidence plus uncertainty handling. A structured object with a decision label, rationale, citations, confidence, and a review flag turns RAG output into an actionable business result while keeping traceability to retrieved policy clauses. Raw chunks, summaries, or conversational text may help a human reason, but they do not reliably drive automated routing or escalation.

• Free-form summary is useful context, but it does not provide stable fields for workflow routing.
• Raw retrieval output exposes evidence, but it leaves the decision and escalation logic unresolved.
• Conversational response adds interaction, but the scenario needs a routable decision artifact, not an open-ended chat turn.

Question 6

Topic: Design Applications

A team is building a Databricks RAG app for customer support managers. The retriever returns the right policy snippets from a Unity Catalog-governed Vector Search index, and the selected Foundation Model API endpoint answers accurately, but the response is free-form prose. A downstream workflow must parse only summary, risk_level, and next_action fields as JSON for a Delta table. Which prompt adjustment is the best engineering decision?

Options:

• A. Require citations before the final answer.

• B. Ask for a concise answer in bullet points.

• C. Ask the model to reason step by step.

• D. Define the JSON schema and require JSON-only output.

Best answer: D

Explanation: Structured-response prompt design should make the output contract explicit. In this scenario, retrieval quality and answer accuracy are already acceptable; the failure is that the model is not producing a parseable shape for the downstream Delta workflow. The prompt should specify the required JSON object, the exact keys, expected value style or types if needed, and that no extra prose should be included. This directly converts the answer from natural language into a machine-readable response. Concision, citations, or step-by-step reasoning may improve other qualities, but they do not satisfy a strict structured-output requirement and can even add text that breaks parsing.

• Bullet points may improve readability, but they are still not the required JSON object.
• Citations first add useful traceability, but they violate the parse-only output constraint unless included in the schema.
• Step-by-step reasoning can add extra text and does not address the downstream JSON contract.

Question 7

Topic: Design Applications

A Databricks team is triaging GenAI backlog items. They will use a generic one-step prompt only when the task can be completed from user-provided text without tool routing or specialized agents. Which backlog item is better served by an Agent Bricks capability?

Options:

• A. Rewrite the pasted status update

• B. Generate slogans from a campaign goal

• C. Resolve cross-domain issues by routing specialists

• D. Extract the due date from one sentence

Best answer: C

Explanation: Agent Bricks is a better fit when the use case needs a higher-level agentic pattern rather than a single prompt transformation. In the artifact, the deciding requirements are routing subquestions to different specialists, using multiple knowledge sources, merging results, citing evidence, and flagging conflicts. A one-step prompt is appropriate when all needed information is already in the prompt and the model only needs to rewrite, extract a simple field, or generate short creative text. The cross-domain triage task needs orchestration, not just prompt wording.

• Rewrite task is a direct transformation of user-provided text, so a simple prompt template is sufficient.
• Simple extraction uses one visible sentence and does not require Information Extraction workflows over documents or tool routing.
• Slogan generation is open-ended text generation from a short brief, not an agentic coordination problem.

Question 8

Topic: Design Applications

An insurance team receives PDFs and email attachments with free-text claim narratives. Before any agent can route the case, a Databricks workflow must populate required fields such as claim_id, loss_date, estimated_amount, and coverage_issue in a Delta table. Which Agent Bricks choice best fits this first pipeline step?

Options:

• A. Use Agent Bricks Knowledge Assistant to answer questions from the documents.

• B. Create a Vector Search index over the raw document text.

• C. Use Agent Bricks Multiagent Supervisor to coordinate routing agents.

• D. Use Agent Bricks Information Extraction to map documents to the schema.

Best answer: D

Explanation: Agent Bricks Information Extraction is the fit when the first task is transforming unstructured or semi-structured content into specified structured fields. In this scenario, downstream routing depends on a Delta table with claim attributes, so the pipeline needs extraction against a target schema before retrieval, chat, or multi-agent orchestration. A Knowledge Assistant is better for question answering over knowledge sources, while a Multiagent Supervisor helps coordinate multiple agents after tasks are defined. Vector Search can support semantic retrieval, but indexing raw text does not by itself produce the required columns.

• Knowledge Assistant answers questions over content rather than producing a governed row of extracted fields.
• Multiagent Supervisor is premature because coordination and routing come after the claim attributes exist.
• Vector Search improves semantic retrieval over text but does not transform documents into schema-aligned Delta columns.

Question 9

Topic: Design Applications

A claims team wants to automate intake from supplier incident emails. A downstream Delta pipeline must validate normalized fields and reject records missing required dates. Which Agent Bricks capability best fits the visible requirement?

Artifact: Intake requirement

Sample source:
"On 3/12/26, ACME reported pump #P-884 failed at Plant 7.
Estimated repair: $18,400. Contact: Lina Ortiz."

Required downstream record:
supplier_name, incident_date, asset_id, site, estimated_cost, contact_name

Next step:
Validate fields and write rows to a Delta table

Options:

• A. Genie Space conversational interface

• B. Agent Bricks Information Extraction

• C. Agent Bricks Multiagent Supervisor

• D. Agent Bricks Knowledge Assistant

Best answer: B

Explanation: Information Extraction is the Agent Bricks choice when the main task is converting unstructured or semi-structured content into a defined set of fields. The artifact does not ask for conversational Q&A or agent coordination. It shows an email-like source that must become a structured record with specific columns before validation and writing to Delta. That schema-first transformation is the deciding requirement.

Knowledge Assistant is better for answering questions over knowledge sources, while Multiagent Supervisor is for coordinating multiple agents. The key takeaway is to choose Information Extraction when structured fields are the required output of the source-content step.

• Knowledge Assistant is tempting for using source text, but it is aimed at knowledge retrieval and Q&A rather than producing a fixed record schema.
• Multiagent Supervisor adds orchestration that the scenario does not require because there is one extraction task.
• Genie Space supports conversational data access, not email-to-field transformation for a validation pipeline.

Question 10

Topic: Design Applications

A Databricks team is designing a GenAI pipeline for invoice exception handling. The output will be consumed by an automated workflow.

Artifact: Product requirement note

Input: invoice text + purchase order excerpts
Business action: choose one workflow branch
Allowed branches: RELEASE, BLOCK, REVIEW
Audit need: include reason_code and supporting evidence
Not needed: free-form narrative summary

Which output should the pipeline produce?

Options:

• A. A natural-language summary of invoice and purchase order differences

• B. A conversational explanation of how staff should decide

• C. A structured decision record with branch, reason_code, and evidence

• D. Retrieved chunks with similarity scores for manual review

Best answer: C

Explanation: When a GenAI pipeline must support an automated decision, its output should match the downstream action contract, not just produce readable text. Here, the workflow needs one of three allowed branches plus audit fields. A structured record with constrained values, a reason code, and supporting evidence is decision-ready because it can be validated, routed, logged, and reviewed. A summary or conversational explanation may help a human understand the case, but it does not directly satisfy the workflow requirement.

• Free-form summary may describe the differences, but it does not provide the constrained branch needed by the workflow.
• Retrieved chunks are intermediate RAG context, not the final business decision output.
• Conversational guidance shifts the decision back to staff instead of producing the required workflow result.

Continue in the web app

Use IT Mastery for interactive Databricks Generative AI Engineer Associate practice with mixed sets, timed mocks, topic drills, explanations, and progress tracking.

Try Databricks Generative AI Engineer Associate on Web

Related focused pages

• Free Databricks Generative AI Engineer Associate Full-Length Practice Exam
• Data Preparation
• Application Development
• Deploying GenAI Apps
• Governance
• Evaluation and Monitoring