top of page

Databricks Certified Generative AI Engineer Associate practice exam

Databricks Certified Generative AI Engineer Associate

Timed practice exams for the Databricks Certified Generative AI Engineer Associate on the real exam's 90 minute limit. Databricks states 45 scored questions and up to 10 unscored items, and a full practice exam on the site serves 55. Every question is original and every option is explained. Your score is broken down by the sections Databricks publishes, so you see what to study next. The question bank holds hundreds of practice questions.

Exam facts

  • Questions: 45 scored multiple-choice and multiple-selection questions, plus up to 10 unscored items [2]
  • Time limit: 90 minutes [2]
  • Passing score: Not published by Databricks [3]
  • Exam fee: USD 200, plus applicable taxes [2]
  • Exam languages (real exam): English, Japanese, Brazilian Portuguese and Korean [2]
  • Validity: 2 years [2]

Tokens: 1 for $4.99, 5 for $14.99, 10 for $24.99 or 25 for $49.99. One token runs a full timed Databricks Certified Generative AI Engineer Associate practice exam, and every shorter session on that exam is then free. The Unlimited pass is $149.99 for a year of every practice session on every exam.

Get tokens

Exam sections and weights

Databricks publishes these sections and objectives for Databricks Certified Generative AI Engineer Associate, quoted here as Databricks words them. [2]

Section 1: Design Applications, 14% of the exam

  • "Design a prompt that elicits a specifically formatted response"
  • "Select model tasks to accomplish a given business requirement"
  • "Select chain components for a desired model input and output"
  • "Translate business use case goals into a description of the desired inputs and outputs for the AI pipeline"
  • "Define and order tools that gather knowledge or take actions for multi-stage reasoning"
  • "Determine how and when to use Agent Bricks (Knowledge Assistant, Multiagent Supervisor, Information Extraction) to solve problems"

Section 2: Data Preparation, 14% of the exam

  • "Apply a chunking strategy for a given document structure and model constraints"
  • "Filter extraneous content in source documents that degrades quality of a RAG application"
  • "Choose the appropriate Python package to extract document content from provided source data and format"
  • "Define operations and sequence to write given chunked text into Delta Lake tables in Unity Catalog"
  • "Identify needed source documents that provide necessary knowledge and quality for a given RAG application"
  • "Use tools and metrics to evaluate retrieval performance"
  • "Design retrieval systems using advanced chunking strategies"
  • "Explain the role of re-ranking in the information retrieval process"

Section 3: Application Development, 30% of the exam

  • "Select Langchain/similar tools for use in a Generative AI application"
  • "Qualitatively assess responses to identify common issues such as quality and safety"
  • "Select chunking strategy based on model & retrieval evaluation"
  • "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"
  • "Implement LLM guardrails to prevent negative outcomes"
  • "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"
  • "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"

Section 4: Assembling and Deploying Applications, 22% of the exam

  • "Code a chain using a pyfunc model with pre- and post-processing"
  • "Control access to resources from model serving endpoints"
  • "Code a simple chain according to requirements"
  • "Choose the basic elements needed to create a RAG application: model flavor, embedding model, retriever, dependencies, input examples, model signature"
  • "Register the model to Unity Catalog using MLflow"
  • "Create and query a Vector Search index"
  • "Identify how to serve an LLM application that leverages Foundation Model APIs"
  • "Explain the key concepts and components of Mosaic AI Vector Search"
  • "Identify batch inference workloads and apply ai_query() appropriately"
  • "Configure vector search for a particular solution based on number of embeddings, update frequency, latency, and cost requirements"
  • "Configure a persistent datastore to store and retrieve intermediate memory or structured information"
  • "Apply CI/CD best practices such as updating a Vector Search index, promoting prompts across environments, and testing individual components of an agent"
  • "Integrate managed, external, and custom MCP servers based on a given application requirements"
  • "Apply prompt version control and manage prompt lifecycle"
  • "Develop an appropriate interactive user facing interface for an agent usage scenario (Apps, Slack, Teams, etc.)"

Section 5: Governance, 8% of the exam

  • "Use masking techniques as guard rails to meet a performance objective"
  • "Select guardrail techniques to protect against malicious user inputs to a Gen AI application"
  • "Use legal/licensing requirements for data sources to avoid legal risk"
  • "Recommend an alternative for problematic text mitigation in a data source feeding a GenAI application"

Section 6: Evaluation and Monitoring, 12% of the exam

  • "Select an LLM choice (size and architecture) based on a set of quantitative evaluation metrics"
  • "Select key metrics to monitor for a specific LLM deployment scenario"
  • "Evaluate agent performance using MLflow scoring and tracing"
  • "Use inference logging to assess deployed RAG application performance"
  • "Use Databricks features to control LLM costs"
  • "Use inference tables and Agent Monitoring to track a live LLM endpoint"
  • "Identify evaluation judges that require ground truth"
  • "Use AI Gateway (Inference Tables, Usage Tables, and rate limiting) to track an LLM or agent deployed via Agent Framework"
  • "Use Databricks custom Scorers for evaluating agents and LLMs"
  • "Incorporate SME feedback to improve agent performance"

Sample questions

Three questions from the Databricks Certified Generative AI Engineer Associate practice bank, with the answer and why each option is right or wrong.

Question 1

A generative AI engineer is building a nightly job that sends supplier emails to a chat model on Foundation Model APIs. A downstream loader rejects any record that lacks the fields supplier_name, order_id and delivery_date. Valid JSON alone isn't enough. Which `response_format` setting meets this requirement?

  • A. `{"type": "json_schema"}` with a JSON schema that lists the three fields
  • B. `{"type": "json_object"}` with `strict` set to true in the request
  • C. `{"type": "text"}` with a system message that asks for JSON output
  • D. `{"type": "json_object"}` with the three field names written in the user message

Answer: A. json_object guarantees valid JSON only. json_schema with a schema makes the model follow that schema, so use it when downstream code needs fixed fields. [4]

  • A. Right. Setting json_schema enables structured outputs, which makes the model follow the JSON schema you supply, so every record carries the three fields.
  • B. Wrong. `strict` belongs to the json_schema object. json_object still ensures only valid JSON, not a schema.
  • C. Wrong. The text type returns unstructured text. A system message asking for JSON gives no guarantee of valid JSON or of the fields.
  • D. Wrong. json_object makes the response valid JSON but does not make it follow a specific schema, and the loader needs fixed fields.

Question 2

A developer documentation team stores its product guides as Markdown files in a Unity Catalog volume. Every task in a guide sits under its own header, and few tasks run past a page. Retrieval must return a whole task, never half of one and never two tasks merged. Which chunking approach fits these guides?

  • A. Split each file at a fixed count of 512 tokens.
  • B. Split each file at its Markdown headers with MarkdownHeaderTextSplitter.
  • C. Embed each whole guide as a single chunk.
  • D. Split each file every 500 characters with CharacterTextSplitter.

Answer: B. Format-specific chunking uses a document's own structure, such as Markdown headers, to set chunk boundaries. [5]

  • A. Wrong. A fixed token count ignores where a task starts and ends, so chunks split tasks or run into the next one.
  • B. Right. Markdown carries structure that can set chunk boundaries, and MarkdownHeaderTextSplitter splits on its headers, so each task lands in a chunk of its own.
  • C. Wrong. A whole guide holds many tasks, so one chunk merges them and brings irrelevant text into every retrieval.
  • D. Wrong. A fixed character count is quick to set up but rarely gives coherent chunks, so tasks get cut wherever the count runs out.

Question 3

A generative AI engineer builds a LangChain chain in a Databricks notebook attached to serverless compute. Each call to `invoke` returns a good answer, but the notebook's MLflow experiment shows no traces at all. The same code logged traces when a colleague ran it on another setup. What explains the missing traces?

  • A. Auto tracing for LangChain captures `stream` calls only, so `invoke` calls are skipped.
  • B. On serverless compute, autologging isn't turned on automatically, and the notebook never turned on LangChain tracing.
  • C. LangChain chains are traced only after they are logged as an MLflow model.
  • D. The notebook lacks `DATABRICKS_HOST` and `DATABRICKS_TOKEN`, so traces can't reach the experiment.

Answer: B. Serverless compute doesn't enable autologging on its own. A LangChain app on serverless needs the LangChain autolog call made explicitly, and invoke, batch and stream are then traced. [6]

  • A. Wrong. The engineer calls invoke, and LangChain auto tracing covers invoke as well as batch and stream, so the call type isn't why traces are missing.
  • B. Right. Autologging is not automatically enabled on serverless compute, so the LangChain integration must be turned on explicitly before the chain runs.
  • C. Wrong. Auto tracing logs nested traces to the active experiment when chains are invoked. No model logging step is needed.
  • D. Wrong. Inside a Databricks notebook these credentials are set for you, so they are not what is missing.

Practice for Databricks Certified Generative AI Engineer Associate on ExamSens.ai

ExamSens.ai is not authorized, endorsed or sponsored by Databricks.

References

[1] https://www.databricks.com/learn/certification/genai-engineer-associate

[2] https://www.databricks.com/sites/default/files/2026-10/databricks-certified-gen-ai-associate-exam-guide-august-2026.pdf

[3] https://www.databricks.com/learn/certification/faq

[4] https://docs.databricks.com/aws/en/machine-learning/foundation-model-apis/api-reference

[5] https://docs.databricks.com/aws/en/agents/tutorials/ai-cookbook/quality-data-pipeline-rag

[6] https://docs.databricks.com/aws/en/mlflow3/genai/tracing/integrations/langchain

bottom of page