Databricks ML Platform Engineer interview questions

Compare FSDP2 and ZeRO-3 through one parameter group’s lifetime, a scoped traffic model and a save-resume experiment, rather than a universal speed ranking.

Derive the weighted gradient, test a short micro-batch, and separate activation savings from total memory and communication. Matching the optimizer step is only part of matching a larger batch.

Separate packed base weights, quantization metadata and trainable adapter state. Count the real projection shapes, then leave room for activations and temporary work before calling a one-card configuration feasible.

Offline DPO trains on existing preference pairs, so online rollout and reward services leave the update loop. Account for both responses, decide whether reference scores can be cached, and retain the data-generation and evaluation costs outside training.

Describe logical tensors independently of writer ranks, publish only a complete checkpoint, and reconstruct the target layout from stored chunks. Asynchronous saving reduces blocking but still needs a consistent snapshot and a memory budget.

Follow adapter-specific token rows through a shared base, calculate stored adapter bytes, and separate the resident set from the active batch.

Turn a benchmark number into a bill that survives real utilization, then write the serving contract the gateway enforces and the evaluation the tuned configuration still owes.

Separate frozen weights from trainable state, count rank-16 adapters from matrix shapes, and check peak memory before choosing a fine-tuning layout.

Design a durable dataset and optional working-set cache around access semantics, request overhead and versioned readiness.

Measure batch readiness and producer capacity, then size prefetch for bursts without hiding a sustained throughput deficit.

Plan a reproducible tokenization build: measure CPU demand, choose a safe token dtype, publish complete shards and distinguish token lookup from training resume.

Calculate how many reads a training loader needs in flight, then see when larger requests waste bandwidth. Worked examples separate useful samples, fetched bytes, prefetch and the limits of Little's Law.

Trace Kubernetes pod placement and Ray bundle reservation as separate layers, including logical GPU limits and autoscaling delay.

Choose the tenant boundary before planning base-model reuse. Account for frozen weights, adapter state and activations separately, then schedule by compatibility, fairness and the real cost of restarting training.

Size notebook capacity from concurrent demand, memory needs and burst tolerance. Choose a sharing mode for the trust model, and make idle release explicit about which state can actually be restored.

A 128,000-ID vocabulary breaks the 16-bit storage estimate. Follow the bytes from raw ingestion to 60 TB of token payload, then design deduplication, manifests and a restartable loader.

Derive adapter bytes from the target matrices, share compatible base weights, and keep each request's cache identity separate. A worked pool design avoids applying the mixed-adapter cost twice.

Bind weights, tokenizer, configuration and evaluation to one immutable release. Follow verification, prefetch, canary readiness and rollback, with bandwidth floors that do not pretend to be rollout measurements.

Define model aliases, permission-aware routing, response reuse and bounded retries. Trace a request whose cached answer becomes invalid after its source permissions change.

Explain the reason for an unpopular migration, choose informative rollout cohorts and describe recovery, communication and transition cost without inventing an incident.

Follow one request from API admission to streamed output, then zoom into the token-generation loop. See where the cache lives, who schedules work, and how workload measurements turn the drawing into a capacity plan.

Count gradient traffic from a named dtype, separate initialization and buffer broadcasts, and measure the reduction tail instead of assuming it is hidden.

Follow the weight bytes through a small decode batch and a long prefill. A scoped roofline calculation explains the difference without pretending to predict actual latency.

Trace GPU credits through reservation, allocation, metering and settlement, with crash-safe ownership and a separate fairness policy.

Follow a token into retained attention state, derive bytes per position for a 70B model, and distinguish present cache usage from the room needed to finish a response.

Track request admission through a concrete page-reservation example, then connect scheduling, growth and stream cleanup to measured service limits.

Derive a 10,240-GPU layout from model work, then account for collective traffic, durable checkpoints, power and replacements. A nested diagram connects tensor, pipeline and data parallel groups to the fleet.

Work from each GPU's cache budget, reserve room for generated tokens, then check latency separately. A limiting-rank example shows why fitting today's prompts is not enough to admit tomorrow's work.