SaveMyCert
Log in
5 of 5 free questions left today·for 30 a day
Databricks GenAI · Domain 3

Application Development practice questions

Application Development is worth 30% of the Databricks GenAI exam — the heaviest of the 6 domains. Building the application: frameworks such as LangChain, prompt augmentation and engineering, quality and safety assessment, guardrails, choosing LLMs and embedding models, and agentic systems with MLflow, Agent Framework and Genie. Official weighting 30%. 6 fully worked examples are further down this page, answers included.

Exam weight
30%
the heaviest of the 6 domains
Questions
179
across 4 topics
Free, no account
5/day
a free account allows 30 a day
Explanations
Every option
right and wrong

Build a practice session

5 free questions left today.

Domains

How many?

Mode

Ready when you are

10 fresh questions drawn across 1 of 6 domains, in Learn mode.

Focused review

Every question you answer incorrectly, and every question you flag while practising, is saved here automatically. Finish a session and you can come back to re-drill just those.

6 sample Application Development questions, fully explained

Questions from the Databricks GenAI bank mapped to domain 3, with the answer key and the reasoning behind every option. None of them repeat the examples on the main Databricks GenAI practice page.

Question 1Application Development

A Generative AI Engineer is designing a support agent that calls tools, inspects each result and loops back to try another tool when one fails. Refund requests must pause for a human approver and resume hours later from the same point, with the conversation state intact. Which framework is the best fit for this control flow?

Choose one.

  • a
    LangChain, piping a fixed sequence of runnables into one linear chain

    A linear chain runs its steps once in order. It has no built-in loops or persisted state to pause for a human and resume later.

  • b
    LangGraph, modelling the steps as a graph with cycles and a checkpointer Correct

    LangGraph is built for stateful workflows: nodes and edges allow loops and branches, and a checkpointer persists state so a run can pause for approval and resume.

  • c
    LlamaIndex, indexing the support documents behind a single query engine

    LlamaIndex centres on indexing and querying data. A query engine answers questions; it does not model looping tool calls with human approval.

  • d
    DSPy, defining signatures for each step and compiling against a metric

    DSPy improves prompts against a metric. It does not provide checkpointed, resumable control flow with approval pauses.

The concept

LangGraph adds stateful, cyclical and resumable control flow on top of LangChain components.

Why that’s the answer

Two requirements decide it: loops (retry another tool after a failure) and durable state across a pause (human approval hours later). LangGraph models the agent as a graph whose edges can cycle and whose checkpointer saves state for resumption. A plain LangChain chain is linear and stateless, LlamaIndex is data-centric, and DSPy is an optimizer.

How to reason it out
  1. Spot loops and branches in the requirement.
  2. Spot the need to pause and resume with saved state.
  3. Choose the framework that offers cycles plus checkpointing.

Exam tip: Loops, branches and pause-resume state point to LangGraph, not a linear chain.

Databricks GenAI Engineer: LangChain, Prompt Augmentation and Prompt Engineering — the lesson that teaches this.

Question 2Application Development

A Generative AI Engineer has an app that makes one call to a Foundation Model API chat endpoint with a fixed prompt. A security review requires the fewest added third-party packages, and the team must capture an MLflow trace of every call during development. Which approach meets both requirements?

Choose one.

  • a
    Wrap the call in a LangChain chain with ChatDatabricks and enable mlflow.langchain.autolog()

    This produces traces, but it adds LangChain packages for a single call, breaking the fewest-packages requirement.

  • b
    Model the call as a one-node LangGraph graph and attach a checkpointer to record it

    A checkpointer saves graph state for resumption; it is not tracing. It also adds a framework the single call does not need.

  • c
    Call the endpoint with the OpenAI client and enable mlflow.openai.autolog() Correct

    Foundation Model APIs are OpenAI-compatible, so the existing client works with no framework. MLflow's OpenAI autologging records each call as a trace.

  • d
    Call the endpoint with the OpenAI client and record each prompt with mlflow.log_param()

    This keeps the dependencies small, but logging a parameter to a run is not a trace and captures neither the response nor timing spans.

The concept

A framework is optional: a single call can use the OpenAI-compatible client directly, and MLflow autologging traces it.

Why that’s the answer

Frameworks earn their place when they remove glue code. One fixed call needs none, and Foundation Model API endpoints accept the OpenAI client. MLflow tracing autologging covers that client, so traces come without adding LangChain or LangGraph. The LangChain option traces but adds packages; the log_param option keeps packages low but produces no traces.

How to reason it out
  1. Check whether the app's flow actually needs an orchestration framework.
  2. Recall that Foundation Model APIs are OpenAI-compatible.
  3. Pick the tracing method that matches the client you keep.
  4. Reject options that meet one requirement and break the other.

Exam tip: One fixed call needs no framework: use the OpenAI-compatible client and trace it with MLflow autologging.

Databricks GenAI Engineer: LangChain, Prompt Augmentation and Prompt Engineering — the lesson that teaches this.

Question 3Application Development

A Generative AI Engineer's team spends weeks hand-tuning the prompts of a classify-then-extract pipeline every time they switch to a new model. They have 300 labeled examples and an accuracy metric. They want the framework itself to search for better instructions and few-shot demonstrations whenever the model changes. Which tool should they adopt?

Choose one.

  • a
    LangChain, holding the 300 examples in a FewShotPromptTemplate for each step

    A few-shot template inserts examples you choose. It does not search for better instructions or demonstrations against a metric.

  • b
    DSPy, declaring each step as a module and compiling it against the metric Correct

    DSPy treats prompts as parameters: signatures declare inputs and outputs, and its compiler searches for instructions and demonstrations that maximize the metric.

  • c
    LangGraph, routing each step through a graph whose nodes keep shared state

    LangGraph controls flow and state. Prompt text in each node is still hand-written and hand-tuned.

  • d
    MLflow Prompt Registry, saving each hand-tuned prompt as a new version

    The registry versions prompts and makes rollback easy, but the tuning itself would still be manual.

The concept

DSPy optimizes prompts programmatically from examples and a metric instead of relying on hand-written prompts.

Why that’s the answer

The team has the two inputs an optimizer needs, labeled examples and a metric, and wants the search automated per model. DSPy's compiler does that for modules defined by signatures. Few-shot templates and LangGraph still need manual prompt work, and the registry only stores versions.

How to reason it out
  1. Note the inputs available: labeled data and a metric.
  2. Note the goal: automatic search for instructions and examples.
  3. Pick the tool whose compiler optimizes prompts against a metric.

Exam tip: Metric plus labeled examples plus 'stop hand-tuning' points to DSPy.

Databricks GenAI Engineer: LangChain, Prompt Augmentation and Prompt Engineering — the lesson that teaches this.

Question 4Application Development

A Generative AI Engineer's agent loads its prompts from the MLflow Prompt Registry with load_prompt(). The team has an evaluation dataset and Correctness and Guidelines scorers. They want better prompt text generated automatically, kept under version control next to the current prompts, and they do not want to rewrite the agent in a new framework. What should the engineer do?

Choose one.

  • a
    Re-implement the agent as a DSPy program and compile it against the scorers

    DSPy can optimize prompts, but this requires rewriting the agent in a new framework, which the team ruled out.

  • b
    Run mlflow.genai.optimize_prompts() on the prompt URIs, dataset and scorers Correct

    This API takes the registered prompts, training data and scorers, improves the prompt text and registers the result as a new prompt version, with no framework change.

  • c
    Run mlflow.genai.evaluate() on the dataset with the scorers for each prompt

    Evaluation measures how good a prompt is. It does not generate improved prompt text.

  • d
    Fine-tune the serving model on the dataset and keep the current prompt text

    Fine-tuning changes the model, not the prompt, and creates a custom model to maintain rather than a new prompt version.

The concept

MLflow can optimize registered prompts automatically and save the result as a new registry version.

Why that’s the answer

Three constraints decide: automatic improvement, version control alongside the existing prompts, and no framework rewrite. mlflow.genai.optimize_prompts() works on registry URIs with a dataset and scorers and registers the optimized text as a new version. DSPy would work only after a rewrite, evaluate() scores but does not improve, and fine-tuning leaves the prompt unchanged.

How to reason it out
  1. List the constraints: automatic, versioned, no rewrite.
  2. Separate tools that measure prompts from tools that improve them.
  3. Pick the optimizer that works on prompts already in the registry.

Exam tip: Prompts already in the registry plus scorers: optimize in place with mlflow.genai.optimize_prompts().

Databricks GenAI Engineer: LangChain, Prompt Augmentation and Prompt Engineering — the lesson that teaches this.

Question 5Application Development

A Generative AI Engineer is writing a LangChain chain in a Databricks notebook. The chain must send its formatted prompt to a chat model that is served on a Databricks Model Serving endpoint through Foundation Model APIs. Which databricks-langchain class should the engineer use for that step?

Choose one.

  • a
    DatabricksEmbeddings, constructed with the serving endpoint's name

    DatabricksEmbeddings calls an embedding endpoint and returns vectors, not chat completions.

  • b
    ChatDatabricks, constructed with the serving endpoint's name Correct

    ChatDatabricks is the LangChain chat-model integration for Databricks Model Serving endpoints.

  • c
    DatabricksVectorSearch, constructed with the index's full name

    This is the vector store integration for Vector Search indexes; it retrieves documents rather than generating replies.

  • d
    UCFunctionToolkit, constructed with the function's full name

    This toolkit turns Unity Catalog functions into tools for an agent; it does not call a chat model.

The concept

databricks-langchain supplies one integration class per Databricks resource; ChatDatabricks is the chat model.

Why that’s the answer

The step is generation by a chat model on a serving endpoint, which is ChatDatabricks. The other classes are real integrations for different resources: embeddings, Vector Search indexes and Unity Catalog functions.

How to reason it out
  1. Name the resource the step talks to: a chat model endpoint.
  2. Map it to its databricks-langchain class.
  3. Rule out classes for embeddings, indexes and tools.

Exam tip: Chat model on Model Serving in LangChain: ChatDatabricks.

Databricks GenAI Engineer: LangChain, Prompt Augmentation and Prompt Engineering — the lesson that teaches this.

Question 6Application Development

A Generative AI Engineer has a Delta Sync index with self-managed embeddings: the source table's vector column was computed with the databricks-gte-large-en endpoint, and the text is in the column chunk. The engineer now wants a LangChain retriever over the index that embeds each user query. Which construction is correct?

Choose one.

  • a
    DatabricksVectorSearch(index_name=idx, text_column="chunk", embedding=DatabricksEmbeddings(endpoint="databricks-bge-large-en"))

    The arguments have the right shape, but the query would be embedded by a different model than the documents, so the vectors would not be comparable.

  • b
    DatabricksVectorSearch(index_name=idx), relying on the index to embed each query with its own endpoint

    Only indexes with Databricks-managed embeddings embed queries themselves. A self-managed index needs the embedding and text column supplied.

  • c
    DatabricksVectorSearch(index_name=idx, embedding=DatabricksEmbeddings(endpoint="databricks-gte-large-en"))

    The embedding model is the right one, but a Delta Sync index with self-managed embeddings also needs text_column, so the retriever cannot be built this way.

  • d
    DatabricksVectorSearch(index_name=idx, text_column="chunk", embedding=DatabricksEmbeddings(endpoint="databricks-gte-large-en")) Correct

    Self-managed embedding indexes need the text column and an embedding object, and the query must be embedded by the same model that embedded the documents.

The concept

With self-managed embeddings, the retriever must embed queries itself with the same model used for the documents.

Why that’s the answer

DatabricksVectorSearch needs both text_column and embedding for direct access indexes and for Delta Sync indexes with self-managed embeddings. The embedding must be the same model that produced the stored vectors, here databricks-gte-large-en, wrapped in DatabricksEmbeddings. Leaving out the embedding fails for this index type, leaving out text_column fails too even with the right model, and a different model gives incomparable vectors.

How to reason it out
  1. Identify the index type: Delta Sync with self-managed embeddings.
  2. Recall that this type needs both text_column and embedding on the retriever.
  3. Match the query embedding model to the document embedding model.

Exam tip: Self-managed vectors: give the retriever the text column and the same embedding model, via DatabricksEmbeddings.

Databricks GenAI Engineer: LangChain, Prompt Augmentation and Prompt Engineering — the lesson that teaches this.

What Databricks GenAI domain 3 tests, topic by topic

The official exam guide breaks Application Development into 4 topics. The question bank follows the same split, so a weak topic shows up as a cluster of misses you can go back and read.

Published Databricks GenAI practice questions per topic in Application Development
TopicWhat it coversQuestions
Frameworks, prompt augmentation and prompt engineeringOfficial exam guide (March 18, 2026), Section 3 objectives: Select Langchain/similar tools for use in a Generative AI application; Augment a prompt with additional context from a user's input based on key fields, terms, and intents; Create a prompt that adjusts an LLM's response from a baseline to a desired output.45
Response quality, safety and guardrailsOfficial exam guide (March 18, 2026), Section 3 objectives: Qualitatively assess responses to identify common issues such as quality and safety; Select chunking strategy based on model & retrieval evaluation; Implement LLM guardrails to prevent negative outcomes.45
Choosing LLMs and embedding modelsOfficial exam guide (March 18, 2026), Section 3 objectives: Select the best LLM based on the attributes of the application to be developed; Select an embedding model context length based on source documents, expected queries, and optimization strategy; Select a model from a model hub or marketplace for a task based on model metadata/model cards; Select the best model for a given task based on common metrics generated in experiments.44
Agentic development with MLflow, Agent Framework and GenieOfficial exam guide (March 18, 2026), Section 3 objectives: Utilize MLflow and Agent Framework for developing agentic systems; Compare the evaluation and monitoring phases of the Gen AI application life cycle; Enable multi-agent systems to leverage Genie Spaces or conversational API to retrieve data.45
Total179

Revise Application Development before you drill it

Databricks GenAI Engineer: LangChain, Prompt Augmentation and Prompt EngineeringExpect scenario questions in which a Generative AI Engineer has a specific application and a deciding constraint, such as fewest packages, no redeploy, no framework rewrite, cost or latency per request, exact current values, or output that code must parse. Framework items ask which tool or databricks-langchain class fits a control flow or resource, and which constructor arguments an index type requires. Prompt Registry items test variable syntax, version versus alias URIs, and how to promote, fix or roll back a prompt. Augmentation items describe what a user's request contains and ask what to look up, expand or add to the prompt and in what structure and order. Prompt engineering items describe a baseline output and a target and ask which prompt change closes the gap; several options are plausible, and model settings such as temperature and max_tokens are common alternatives that do not address the stated gap. Some items are multiple response.Databricks GenAI Engineer: Response Quality, Safety and LLM GuardrailsExpect scenario questions that hand you a trace, an evaluation table or a red-team finding and ask which issue it shows or which change fixes it. Response-assessment items describe an answer and its retrieved context and ask you to name the issue (relevance, completeness, groundedness, format, safety, over-refusal) or the stage that failed, and several options are real issues that the scenario's details rule out. Chunking items give evaluation symptoms or metrics with a constraint such as a prompt-token budget, an embedding model or a context window, and some require arithmetic. Guardrail items turn on Databricks behaviour: which AI Gateway feature actually screens content, per-endpoint scope, the streaming and embeddings limits of output guardrails, the deprecated topic and keyword filters, Llama Guard custom categories and verdict format, and when a deterministic code check beats a prompt rule. Constraints such as no code changes, no retraining, no extra model cost or no unscreened text decide between workable options. A few items ask you to select two.Databricks GenAI Engineer: Choosing LLMs and Embedding ModelsExpect scenario questions that describe an application and ask which LLM, embedding model or experiment run to choose. Most hinge on one stated constraint: lowest cost or latency once quality ties, a context window that must hold input plus output, in-workspace processing or future fine-tuning, generally available features only, a commercial licence, or one index row per document. Embedding items give chunk, document and query lengths and ask which endpoint fits, or diagnose bad retrieval after a model switch. Model-card items show card fields (languages, context, licence, task) and ask which model goes forward. Metric items show a table of MLflow runs or a class imbalance and ask which metric or run decides. Some items are multiple selection.Databricks GenAI Engineer: Building Agents with MLflow, Agent Framework and GenieExpect scenario questions that describe an agent, a constraint and a symptom, then ask which change, configuration or call fits. Agent Framework items turn on how an agent is wrapped (ResponsesAgent, streaming, custom inputs), logged (Models from Code, code paths, validation), authenticated (declared resources versus on-behalf-of-user, including what a Genie space needs) and deployed (what one deploy call provides, rolling out a version without changing the URL). Life-cycle items contrast offline evaluation with production monitoring: which judges can run without expectations, how sampling and filtering are configured per scorer, and how production traces become labeled evaluation data. Genie items ask when structured data belongs in a Genie space rather than a retriever, how a supervisor routes to Genie workers, where a fix belongs (the space's curation versus the calling agent), and how the Conversation API is polled, continued and permissioned. Several options often work in principle; constraints such as no downtime, no long-lived credentials, per-user filters, budget or least code decide between them.

Other Databricks GenAI domains

Domain 1: Design Applications14% of the exam · 84 questionsDomain 2: Data Preparation14% of the exam · 84 questionsDomain 4: Assembling and Deploying Applications22% of the exam · 132 questionsDomain 6: Evaluation and Monitoring12% of the exam · 72 questionsAll Databricks GenAI practice questionsMixed sessions across all 6 domains — the way the real exam interleaves them.

Application Development: your questions

Application Development is domain 3 of the Databricks GenAI exam guide and carries 30% of the scored content — the heaviest of the 6 domains. On a 45-question paper that works out to roughly 14 questions, though Databricks does not publish an exact per-domain count and individual exam forms vary.

Source

The domain weight and topic list on this page come from the official Databricks GenAI exam guide.