Home / GenAI Engineer practice test / Design Applications

Free · 8 questions with explanations

Design Applications: Databricks Generative AI Engineer Associate Practice Questions

Exam-style questions on Design Applications. Pick your answer, then open the explanation to see why it's right — and why the other options are wrong.

Updated November 11, 2026

1 Design Applications

A generative AI engineer is building a multi-turn customer support bot using LangChain on Databricks. The bot must: (1) ground all answers strictly in internal company documentation stored in a Databricks Vector Search index, (2) maintain context across multiple conversation turns so users can ask follow-up questions like 'Tell me more about the second option you mentioned', and (3) return responses as concise plain text. Which combination of LangChain chain components is REQUIRED to fulfill all three requirements?

  1. APromptTemplate, LLM and StrOutputParser, relying on the LLM object to keep earlier responses in its internal state
  2. BChatPromptTemplate with a MessagesPlaceholder for chat history, a VectorStoreRetriever, a ChatModel and a StrOutputParser
  3. CVectorStoreRetriever and MapReduceDocumentsChain, which processes the documents in parallel and merges the history
  4. DLLM and ConversationBufferMemory, since accumulated conversation turns supply enough context for follow-up questions
  5. EPromptTemplate, Retriever and LLM, since the documentation can answer each follow-up from the current message alone
Show answer & explanation

Correct answer: B

WHY B is correct: All three requirements map to specific LangChain components. (1) Grounding in documentation requires a VectorStoreRetriever — it queries the Databricks Vector Search index with the current user question and returns relevant document chunks as context. (2) Multi-turn awareness requires injecting prior conversation turns into the prompt — this is achieved with ChatPromptTemplate that includes a MessagesPlaceholder slot for chat history (populated by a memory component or passed explicitly). (3) Plain text output requires StrOutputParser. The ChatModel (rather than a base LLM) is appropriate for conversational use cases because it accepts structured message types (system/human/AI). WHY NOT A: A basic PromptTemplate + LLM + StrOutputParser chain has no retriever — it cannot ground answers in company documentation at all. LangChain LLMs do NOT automatically store state; memory must be explicitly configured. This option fails requirements 1 and 2. WHY NOT C: MapReduceDocumentsChain is designed for processing a large set of documents by mapping over chunks and reducing to a final summary. It is not a conversational chain and does not manage multi-turn history. It would be used for document summarization, not real-time multi-turn QA. WHY NOT D: Memory accumulates conversation history but does NOT provide access to the documentation vector store. If the user asks about a policy not yet discussed in the conversation, the memory-only chain cannot answer correctly. Retrieval is required for grounded answers — memory alone is insufficient. WHY NOT E: A PromptTemplate + Retriever + LLM without history management fails requirement 2. A follow-up question like 'Tell me more about the second option you mentioned' requires context from the previous AI response to be meaningful. Without history, the model treats each turn as a fresh, independent question.

2 Design Applications

A business intelligence team at a manufacturing company wants to enable 200 non-technical business users to query their Databricks Delta Lake tables (production metrics, inventory levels, sales by region) using plain English. A user should be able to type 'What were the top 5 underperforming product lines by revenue last quarter?' and receive an accurate, data-grounded answer — without writing SQL, without filing a ticket to the data team, and without custom agent development. Unity Catalog governance must be automatically enforced. Which Databricks Agent Bricks use case is MOST appropriate for this scenario?

  1. AKnowledge Assistant: upload the table schemas as PDF documentation and answer questions by searching those documents
  2. BInformation Extraction: scan the Delta tables on a schedule and extract business KPIs into a summary table exposed to users
  3. CAI/BI Genie: create a Genie space over the Unity Catalog tables that generates and runs SQL from natural language questions
  4. DSupervisor Agent: route each question to a production, inventory or sales sub-agent that writes custom SQL for its own domain
  5. ECustom LLM: fine-tune a model on the company's historical SQL queries and table schemas so it generates SQL for new questions
Show answer & explanation

Correct answer: C

WHY C is correct: AI/BI Genie is the Databricks Agent Brick specifically designed to 'turn your tables into an expert AI chatbot.' It takes Delta Lake tables registered in Unity Catalog as its data source, interprets natural language questions, generates SQL, executes it against the live data, and returns grounded answers — precisely the use case described. Unity Catalog access controls are applied automatically because Genie operates within the Unity Catalog governance framework, ensuring each user only sees data they are authorized to access. This requires zero custom agent development and is designed for non-technical users. WHY NOT A: Knowledge Assistant is designed for document-based Q&A (PDF, text files, unstructured content). Uploading schema documents does not give the chatbot access to the actual data in the Delta tables — it can only answer schema-level questions ('What columns does the sales table have?'), not data-level questions ('What were the top 5 underperforming product lines?'). Knowledge Assistant cannot execute SQL or query live tables. WHY NOT B: Information Extraction is designed to transform unstructured documents (invoices, emails, contracts) into structured fields — not to query existing structured Delta tables. Pre-extracting KPIs into a summary table requires knowing in advance every question users might ask, which is impossible and defeats the purpose of a natural language interface. WHY NOT D: Building a Supervisor Agent with domain-specific sub-agents that write custom SQL requires significant engineering effort per sub-agent, custom SQL logic maintenance, and periodic updates as schemas evolve. This contradicts the 'without custom agent development' requirement. Genie provides this capability out of the box. WHY NOT E: Fine-tuning a Custom LLM bakes knowledge of the table schemas into the model weights at training time. This approach cannot access live data (fine-tuned weights do not execute SQL), requires periodic retraining as schemas change, and produces stale answers. It is inappropriate for real-time tabular data querying.

3 Design Applications

A retail company's product manager describes a new AI feature: 'When a customer views their order history page, show them 3 products we think they'll love, along with a short explanation of why each product is a good fit for them personally.' A generative AI engineer must translate this business description into a formal input/output specification for the AI pipeline. Which specification BEST captures the requirement?

  1. AInput: the user's purchase history and a product catalog or index. Output: 3 product objects, each with product_name and a short reasoning.
  2. BInput: a product catalog file sorted by popularity. Output: the 3 best-selling products overall, as a numbered list of product names.
  3. CInput: the full text of the product reviews the customer has written. Output: one paragraph summarizing the customer's tastes, without named products.
  4. DInput: the customer's demographic profile (age group, zip code, gender). Output: the 3 products most bought in that segment, without an explanation.
  5. EInput: the embedding of the most recently purchased product. Output: cosine similarity scores for the catalog, sorted descending, with the top 3 shown.
Show answer & explanation

Correct answer: A

WHY A is correct: The business goal has two parts: personalization, which needs the customer's own purchase history plus the catalog of available products as input, and a short explanation per item, which needs a reasoning field in the output. Three structured objects with product_name and reasoning map directly onto what the product manager described. WHY NOT B: A global best-seller list shows the same three products to every customer, so it is not personalized. Returning product names alone also drops the required explanation of why each product fits this customer. WHY NOT C: A paragraph about the customer's tastes is not a recommendation. The product manager asked for three specific products; a taste profile could be an intermediate step in the pipeline but is not the final output. WHY NOT D: Demographic targeting is not the same as personalization from the customer's actual purchase behavior, and this specification leaves out the personalized explanation the feature requires. WHY NOT E: Raw cosine similarity scores are an intermediate computation, not something to show on a customer-facing page, and the feature calls for a human-readable explanation. Using a single recent purchase also discards the wider history needed for good personalization.

4 Design Applications

A financial research firm has 5,000 unstructured equity analyst reports stored as PDFs in a Unity Catalog Volume. Analysts frequently ask questions like 'What risks did analysts identify for semiconductor companies in Q2 2024?' and 'Summarize the investment thesis for TSMC across reports from the last 6 months.' The firm wants a pre-built solution that can search across all reports, cite specific source documents in its answers, and requires minimal engineering effort to deploy. Which Agent Bricks use case is MOST appropriate?

  1. AKnowledge Assistant, which turns the PDF reports into a searchable knowledge base and answers questions with cited sources
  2. BAI/BI Genie, with the PDF Volume registered as a Unity Catalog table so that Genie generates SQL over the document content
  3. CInformation Extraction, configured to pull risk factors, investment theses and company names from each report into a queryable Delta table
  4. DSupervisor Agent, which creates a specialized sub-agent for each analyst report and routes each question to the relevant report's agent
  5. ECustom LLM, fine-tuned on the 5,000 reports so that the model answers from its own weights without a retrieval step
Show answer & explanation

Correct answer: A

WHY A: Knowledge Assistant is the Databricks Agent Brick explicitly designed to 'turn your documents into a high-quality chatbot that can answer questions and cite its sources.' Natural language Q&A over unstructured PDF documents with source citations is precisely what it is built for. It handles document ingestion, chunking, embedding, vector indexing, retrieval, and answer generation with citations in a pre-configured pipeline that requires minimal engineering effort. Source citation is a first-class feature, directly addressing the analysts' need to trace answers back to specific reports. WHY NOT B: AI/BI Genie is designed for structured tabular data (Delta tables). PDF files are binary unstructured documents, and registering a PDF Volume as a Unity Catalog table does not make the text content queryable via SQL. SQL operates on structured rows and columns, not on binary PDF byte streams. WHY NOT C: Information Extraction is designed for structured field extraction (for example 'extract vendor name, date, amount from each invoice'). Pre-extracting everything from 5,000 reports to cover every future question is infeasible, because you cannot anticipate every analytical question. Free-form questions such as 'Summarize the investment thesis' need retrieval and generation, not lookups of pre-extracted fields. WHY NOT D: A separate sub-agent per report is not a scalable architecture for 5,000 documents. It would require 5,000 individually configured agents and a routing mechanism to decide which reports are relevant to each question. Knowledge Assistant's retrieval (vector similarity search across all documents) is designed to avoid this anti-pattern. WHY NOT E: Fine-tuning an LLM does not reliably memorize factual content from training documents; fine-tuned models tend to hallucinate specific facts (prices, dates, company names). Fine-tuning is also expensive, needs regular retraining as new reports arrive, and does not provide source citations. RAG-based approaches (used by Knowledge Assistant) are preferred over fine-tuning for document Q&A.

5 Design Applications

A generative AI engineer is building a ReAct (Reason + Act) agent to answer: 'What is today's closing price of NVDA stock and by what percentage does it differ from its 52-week high?' The agent has access to three tools: get_current_price(ticker: str) -> float, get_52_week_high(ticker: str) -> float, and calculate_percentage_diff(value: float, reference: float) -> float. Which tool execution order is valid, and what reasoning justifies it?

  1. Acalculate_percentage_diff, then get_current_price, then get_52_week_high, because the calculation call establishes which inputs the later calls need to fill in
  2. BThe three tools in one parallel batch, because a ReAct agent issues its available tool calls in a single reasoning step to cut latency
  3. Cget_52_week_high alone, because its response already includes the current price as a sub-field, which makes the other calls redundant
  4. Dget_current_price, then get_52_week_high, then calculate_percentage_diff, because the calculation needs both values as concrete inputs
  5. Eget_current_price, then calculate_percentage_diff, then get_52_week_high, because the price has to be used before the next call displaces it from context
Show answer & explanation

Correct answer: D

WHY D: The compute graph has an explicit dependency structure. calculate_percentage_diff(value, reference) requires two float inputs, the current price and the 52-week high, that must both be known before the function can be invoked. get_current_price and get_52_week_high are independent data-fetching tools with no dependency on each other, so they can be called in either order (or in parallel), but both must complete before the calculation. The ReAct framework iterates: Reason (what data do I need?), Act (call a tool), Observe (record result), then Reason again. In practice: step 1 retrieves the current price, step 2 retrieves the 52-week high, step 3 calls the calculation with both known values. WHY NOT A: calculate_percentage_diff requires actual float arguments; it cannot accept placeholders or unresolved references in a real function call. Calling it first without the two required inputs would raise a TypeError or return a meaningless result. Tools execute synchronously with concrete arguments in the ReAct loop; they do not pre-declare what data will be needed. WHY NOT B: get_current_price and get_52_week_high could in theory be parallelized because they do not depend on each other, but calculate_percentage_diff cannot be in the same parallel batch: it depends on the outputs of both. Calling the three together means the calculation fires with unresolved inputs. Standard ReAct agents execute tool calls sequentially unless explicitly designed for parallel tool invocation. WHY NOT C: Stock price APIs and 52-week high APIs are separate data sources, and the 52-week high tool returns a single float, not the current intraday price. Assuming sub-field availability without knowing the actual API contract would leave the agent with a missing current price. WHY NOT E: Agent context persists all tool results within the same conversation turn; there is no cache displacement mechanism that overwrites a previously observed float when a later tool is called. The order is also wrong: the calculation would be called with only one of its two required inputs.

6 Design Applications

A procurement department receives 800 vendor invoices per month in various formats (PDF, email body text, scanned images). Each invoice must be parsed to extract: vendor_name, invoice_date, line_items (list of {description, quantity, unit_price}), total_amount, and payment_due_date. The extracted data must be written to a Unity Catalog Delta table for downstream accounts payable processing. The team has no ML engineering resources and needs the lowest-engineering-effort solution. Which Agent Bricks use case is MOST appropriate?

  1. AKnowledge Assistant: index the vendor invoices in a chatbot so accounts payable staff can ask for each invoice's fields and record the answers in the table.
  2. BInformation Extraction: define the target fields and let the agent turn the unstructured invoices into structured output for the Delta table.
  3. CAI/BI Genie: store the invoice PDFs in a Unity Catalog volume and have Genie generate INSERT statements for the Delta table from natural language prompts.
  4. DSupervisor Agent: coordinate one sub-agent per vendor, each tuned to that vendor's invoice format, and route each incoming invoice to the matching one.
  5. ECustom LLM: fine-tune a model on two years of historical invoices so it learns each vendor's layout and extracts fields without retrieval or tools.
Show answer & explanation

Correct answer: B

WHY B is correct: Information Extraction is the Databricks Agent Brick designed specifically to 'transform documents and unstructured text into structured insights via information extraction, classification, and more.' The invoice parsing use case — extracting named fields from unstructured documents and writing them to a structured table — is the canonical Information Extraction scenario. The Agent Brick handles document ingestion, field specification, LLM-based extraction, and output structuring in a pre-built pipeline that requires minimal engineering effort. Results can be written directly to a Delta Lake table in Unity Catalog for downstream processing. WHY NOT A: Knowledge Assistant is designed for interactive Q&A with source citations, not for batch automated extraction. Having staff manually ask questions and copy answers into a Delta table adds human labor back into the process — the opposite of automation. Additionally, Knowledge Assistant does not write structured output to Delta tables as part of its workflow; it produces natural language answers. WHY NOT C: AI/BI Genie answers questions about data already in structured Delta tables — it does not parse binary document files or generate bulk INSERT statements from PDFs. The invoice data must first be extracted from unstructured documents before it can be queried or inserted, which is outside Genie's scope. WHY NOT D: Building a per-vendor sub-agent requires significant engineering effort: one agent per vendor, routing logic based on vendor identification, and maintenance as new vendors are onboarded. This directly contradicts the 'lowest engineering effort' requirement. Information Extraction handles vendor format variation through general extraction capability, not vendor-specific models. WHY NOT E: Fine-tuning an LLM on historical invoices embeds vendor-specific layouts into model weights. This approach cannot generalize to new vendors without retraining, requires significant ML infrastructure and expertise, cannot write outputs directly to Delta tables without additional pipeline code, and is incompatible with the 'no ML engineering resources' constraint.

7 Design Applications

A large enterprise is building an AI assistant for their sales team. The assistant needs to answer three categories of questions: (1) data questions like 'How many deals closed in EMEA last quarter?' by querying Delta Lake sales tables, (2) knowledge questions like 'What is our official pricing policy for enterprise tier contracts?' by searching internal policy documents, and (3) action requests like 'Summarize the top 3 competitive risks from the latest market research report.' A single user message may require one, two, or all three capabilities. The enterprise wants a unified conversational interface with minimal custom code. Which Agent Bricks deployment pattern is MOST appropriate?

  1. AThree separate Knowledge Assistants, one per question category, each with its own chat URL so users pick the assistant that fits the question
  2. BA single AI/BI Genie space connected to all the sources, relying on Genie to handle document search, SQL generation and summarization
  3. CA Supervisor Agent that routes each request to a Genie space for data questions, a Knowledge Assistant for policies, and another agent for report summaries
  4. DA single Information Extraction agent that turns the sales data, policies and reports into one structured Delta table queried with SQL
  5. EA single Knowledge Assistant indexed on PDF exports of the sales tables, the policy documents and the research reports
Show answer & explanation

Correct answer: C

WHY C is correct: The Supervisor Agent (Multiagent Supervisor) is the Databricks Agent Brick designed to 'bring Genie spaces and agents together' under a unified coordinator. When a use case spans multiple distinct capabilities — structured data querying (Genie), document search (Knowledge Assistant), and custom agents — a Supervisor coordinates the specialists and presents a single conversational interface to the user. The Supervisor analyzes each user message, determines which agent(s) can fulfill it, routes sub-tasks appropriately, and merges the results into a coherent response. This is the purpose of the Multiagent Supervisor pattern. WHY NOT A: Providing three separate chatbot URLs to the sales team creates a poor user experience — salespeople must decide which tool to use before asking their question, and multi-part questions that require capabilities from two or three assistants cannot be handled at all without manually copying answers between tools. A unified interface is explicitly required. WHY NOT B: AI/BI Genie is designed specifically for structured tabular data (SQL generation). It does not search unstructured documents or summarize PDF market research reports. Claiming Genie handles all three modalities from a single interface misrepresents Genie's designed scope. WHY NOT D: Information Extraction pre-processes documents into structured tables. This works for extracting specific fields (prices, names, dates) but cannot answer open-ended data questions with unknown aggregation logic, cannot answer free-form policy questions requiring semantic understanding, and cannot summarize competitive analysis narratives. Pre-extracting all possible information from live dynamic sales tables and varied documents into one master table is both technically infeasible and semantically reductive. WHY NOT E: Exporting live Delta Lake sales data to PDFs and indexing those PDFs in a Knowledge Assistant is a severe anti-pattern. The sales data becomes stale immediately, PDF exports of tabular data create enormous documents, and vector similarity search over tabular data is far less precise than SQL execution. Knowledge Assistant is not designed to reason over numerical tabular data — AI/BI Genie uses SQL for that purpose.

8 Design Applications

A retail bank receives 50,000 customer complaint emails per day and needs to automatically assign each complaint to one of five case queues: account_access, fraud, fees_and_charges, loan_services, or general_inquiry. The system must require minimal human review and integrate with an existing SQL-based routing system. Which NLP task type and model approach BEST matches this requirement?

  1. AText generation: prompt a large generative LLM to write a summary of each complaint, then parse that summary for routing keywords.
  2. BText summarization: reduce each complaint to one sentence, then run a rule-based keyword matcher on the summary to select the queue.
  3. CNamed entity recognition: extract account numbers, branch names and dates from each complaint and map those entities to the right queue.
  4. DExtractive question answering: pass each complaint as context and ask which queue should handle it, taking the extracted span as the label.
  5. EText classification: use a zero-shot, few-shot or fine-tuned model that assigns one of the five predefined labels to each complaint.
Show answer & explanation

Correct answer: E

WHY E is correct: Text classification is the NLP task built for assigning predefined categorical labels to text, which is exactly what routing to a fixed set of five queues requires. The model can be prompted zero-shot with the queue names, prompted few-shot with examples, or fine-tuned on historical complaints, and its discrete label output maps directly onto SQL routing logic such as a CASE expression or a WHERE filter on the category. WHY NOT A: Text generation produces open-ended free text and is not designed for label assignment. Generating a summary and parsing it for keywords is inefficient and fragile, because the summary may not contain the expected routing keywords, and it adds latency. Generation suits tasks like drafting replies. WHY NOT C: Named entity recognition extracts mentions such as account numbers, dates and amounts. It does not classify the overall topic or intent of the complaint, and those entities do not reliably identify the queue: a fraud complaint and a fees complaint may both contain an account number. WHY NOT D: Extractive question answering returns a span copied from the supplied context. For that to work the complaint itself would have to contain the queue name, which is rarely the case, so it is the wrong task type for routing. WHY NOT B: Summarization followed by keyword matching is a two-step pipeline that adds latency and fragility without improving accuracy over direct classification. Summarization models are not trained to normalize text for keyword matching, and a classifier handles noisy input directly.

Take the full GenAI Engineer practice test →