Home / ML Associate practice test / Model Deployment

Free · 8 questions with explanations

Model Deployment: Databricks Machine Learning Associate Practice Questions

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

Updated November 10, 2026

1 Model Deployment

A batch scoring script constructs JSON requests for a custom model endpoint using pandas rows. The team wants the recommended DataFrame request format that preserves column ordering. Which payload style should they prefer?

  1. Ainputs, because every pandas-based model endpoint expects tensors even when the model signature is tabular
  2. Binstances, because row-oriented tensor payloads are the default for all MLflow pyfunc table models
  3. Cdataframe_split, because Databricks recommends the split-oriented pandas format and it preserves column order
  4. Ddataframe_records, because records orientation guarantees column order more strongly than split orientation
  5. Epredictions, because endpoint requests should mirror the response wrapper used by Databricks serving APIs
Show answer & explanation

Correct answer: C

WHY C: For pandas-style tabular scoring requests, Databricks recommends dataframe_split and notes that it preserves column ordering better than records orientation. WHY NOT A: inputs is for tensor-style payloads. WHY NOT B: instances is also for tensor-oriented inputs. WHY NOT D: records does not guarantee column order. WHY NOT E: predictions is the response wrapper, not the request format.

2 Model Deployment

A serving endpoint for a custom model is already deployed. The engineer wants to call it from an application for real-time inference. Which statement is correct?

  1. AThe application should send a scoring request to the endpoint invocation URL using a supported request format and valid authentication
  2. BThe application should query the Unity Catalog model registry directly, where each registered version exposes a prediction method over HTTP
  3. CThe application should call the endpoint through a Databricks SQL warehouse, as REST invocation is offered for foundation model endpoints
  4. DThe application should poll the training run artifacts in MLflow, as a deployed endpoint does not accept requests from external clients
  5. EThe application should upload the training notebook to the endpoint with each request, letting the serving system rebuild the model context
Show answer & explanation

Correct answer: A

WHY A: Real-time inference on a Databricks serving endpoint is performed by sending authenticated requests to the endpoint invocation API using supported payload formats. WHY NOT B: The registry stores versions but is not the online scoring API. WHY NOT C: REST invocation is supported for custom model endpoints, so going through Databricks SQL is not required. WHY NOT D: MLflow artifacts are not the serving interface; deployed endpoints do accept external prediction requests. WHY NOT E: Notebooks are not uploaded per request; the endpoint already hosts the model.

3 Model Deployment

A team wants to roll out a new model gradually while most live traffic still goes to the current stable model. What is the purpose of traffic splitting on serving endpoints?

  1. ATo divide a training dataset into folds before cross-validation so each candidate model sees a different validation sample
  2. BTo divide one large prediction vector into smaller chunks so a single model can score them on different GPUs in parallel
  3. CTo partition feature tables across storage locations so online and offline features are read from separate catalogs
  4. DTo alternate request payload formats between dataframe_split and tensor inputs for automatic schema discovery
  5. ETo route percentages of live inference requests to different served models or endpoint configurations during rollout
Show answer & explanation

Correct answer: E

WHY E: Traffic splitting is used to send controlled percentages of live inference traffic to different served entities, supporting gradual rollout or comparison. WHY NOT A: That is dataset splitting for training, not serving. WHY NOT C: That concerns storage design, not serving traffic. WHY NOT D: Request payload formats are unrelated. WHY NOT B: Traffic splitting is not model-internal tensor sharding.

4 Model Deployment

Why might a machine learning engineer deliberately send only a small percentage of production requests to a challenger model while keeping the rest on the champion model?

  1. ATo reduce the number of endpoint logs, as inference tables record the majority route and skip the minority route
  2. BTo bypass request authentication for the challenger, as minor traffic shares are treated as internal evaluation
  3. CTo avoid registering the challenger in Unity Catalog, as low-traffic models are served without version control
  4. DTo get batch inference behavior from a real-time endpoint, as small traffic shares are queued and scored offline
  5. ETo compare the challenger under real traffic with limited blast radius before increasing its share or promoting it
Show answer & explanation

Correct answer: E

WHY E: Sending a small share of live traffic to a challenger is a classic low-risk rollout pattern that gathers real production evidence before a wider cutover. WHY NOT A: Logging behavior is not the objective, and inference tables are not limited to the majority route. WHY NOT C: Registration requirements do not disappear because traffic is small; a served model is still a registered version. WHY NOT D: Traffic percentage does not convert real-time serving into batch scoring. WHY NOT B: Authentication requirements still apply to every request.

5 Model Deployment

An operations team receives a steady stream of sensor events and wants model inference embedded inside a managed pipeline that processes arriving records continuously. According to the exam's Databricks deployment pattern, how is streaming inference performed with Delta Live Tables?

  1. ABy exporting each micro-batch to a CSV file and scoring those files later with a nightly batch notebook job
  2. BBy applying the model as a Spark UDF inside the pipeline, where inference runs as the data flows through it
  3. CBy querying the MLflow UI during each trigger interval and copying the latest model outputs into the target table
  4. DBy replacing the data pipeline with a SQL warehouse dashboard that refreshes whenever events arrive from upstream
  5. EBy writing raw events directly to the model registry, which executes the inference logic during table ingestion
Show answer & explanation

Correct answer: B

WHY B: The expected Databricks pattern for streaming inference in Delta Live Tables (now Lakeflow Spark Declarative Pipelines) is to embed model scoring logic, commonly as a Spark UDF, within the pipeline itself. WHY NOT A: CSV exports scored by a nightly notebook create delayed batch processing, not streaming inference. WHY NOT C: The MLflow UI is not a scoring engine; it displays runs and models. WHY NOT D: A dashboard visualizes results; it is not the inference pipeline. WHY NOT E: Model registries store and version models; they do not execute streaming table inference.

6 Model Deployment

A team compares streaming inference with nightly batch scoring. What is the main advantage of the streaming design for event-driven use cases?

  1. AIt processes new data as it arrives, reducing prediction delay compared with waiting for the next scheduled batch window
  2. BIt costs less than batch inference by design, as continuous pipelines keep no checkpoints or state between their runs
  3. CIt removes the need for model packaging, as streaming systems execute raw notebook cells directly in production
  4. DIt delivers lower latency than a real-time serving endpoint for per-event requests regardless of the workload shape
  5. EIt makes feature engineering unnecessary, as micro-batches infer model-ready columns directly from the event streams
Show answer & explanation

Correct answer: A

WHY A: Streaming inference is valuable when the core requirement is to score newly arriving data continuously instead of waiting for a later batch. WHY NOT B: Continuous pipelines can introduce operational cost, and they do maintain checkpoints and state. WHY NOT C: Models still need proper packaging or scoring logic, for example an MLflow model applied as a UDF. WHY NOT D: Streaming and real-time APIs solve different latency patterns; a serving endpoint is the tool for per-request low latency. WHY NOT E: Feature engineering is still required; streams do not produce model-ready columns on their own.

7 Model Deployment

A custom model deploys successfully in training, but fails during endpoint creation because a helper package is missing from the serving container. What is the most direct fix?

  1. AAdd the helper package to the MLflow model's declared dependencies, such as its pip requirements, and then redeploy the model
  2. BRecreate the serving endpoint under a new name to clear the cached container image that is tied to the old endpoint name
  3. CRemove the model signature and redeploy to skip the schema validation step that loads helper packages during startup
  4. DTurn on scale-to-zero for the endpoint to trigger a cold-start rebuild that installs packages absent from the model
  5. EQuery the endpoint with dataframe_records instead of dataframe_split to avoid the parsing path that needs the package
Show answer & explanation

Correct answer: A

WHY A: Serving containers are built from the MLflow model package and its declared dependencies, so a missing library must be added to that environment (for example pip requirements) before redeploying. WHY NOT B: Endpoint names do not control dependency installation; a renamed endpoint builds the same container from the same model. WHY NOT C: Signatures describe input and output schemas and are unrelated to missing Python packages. WHY NOT D: Scale-to-zero controls idle capacity; a cold start does not add undeclared dependencies. WHY NOT E: Request format does not solve a container build issue; the failure happens at endpoint creation, before any query.

8 Model Deployment

A data scientist wants to score a stored MLflow model against a pandas DataFrame inside Python code, without calling a remote serving endpoint. Which workflow is the standard MLflow approach?

  1. ALoad the model with mlflow.pyfunc.load_model and call predict directly on the in-memory pandas DataFrame
  2. BConvert the DataFrame to SQL text and send it through a REST invocation URL even for local batch scoring
  3. CWrap the DataFrame with spark.readStream first, as pandas objects are not valid inputs for pyfunc prediction
  4. DRegister the DataFrame as a Unity Catalog table first, as pyfunc models score named tables and not in-memory data
  5. ECall mlflow.start_run before each prediction batch, as pyfunc predict requires an active tracking run to score
Show answer & explanation

Correct answer: A

WHY A: MLflow pyfunc models support pandas.DataFrame inputs directly, so the normal pattern is load_model followed by predict. WHY NOT B: A remote REST call is unnecessary for local batch scoring, and the stem rules out a serving endpoint. WHY NOT C: pandas DataFrames are explicitly supported pyfunc inputs; no streaming reader is involved. WHY NOT D: In-memory DataFrames can be scored directly without registering a table. WHY NOT E: Prediction does not require an active MLflow run.

Take the full ML Associate practice test →