roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Get ready for MLOps Engineer interviews: taking models from experiment to reliable production. Covers containers and CI/CD, cloud platforms, data pipelines, observability, and the model lifecycle.
9205 of 9205 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 9205 new. 0 cut, outside your plan.
An MLOps loop usually looks like a platform engineering loop with a model inside it: a screen, a Python coding round that is as likely to be a data-validation script as an algorithm problem, one or two infrastructure conversations on containers, Kubernetes and delivery pipelines and, for anyone past junior, an ML system design round; the loop ends on behavioral questions. The infrastructure questions tend to arrive as model problems. A training pod that requests `nvidia.com/gpu` stays Pending on a cluster with idle GPUs: is the device plugin advertising them, and does the pod tolerate the taint on the GPU nodes? A PyTorch image reinstalls every dependency on every commit: which Dockerfile line broke the cache? A job spread across several nodes hangs at its first all-reduce: which rank never joined the collective? A model promoted on Friday is worse by Monday and nothing has errored: did the inputs drift, is a feature computed one way in training and another at serving time, or have the labels simply not arrived yet? Answers that score well treat a model as a build artifact with a lineage: the commit, data snapshot, locked dependencies and seed that produced it, and a rollback that moves a registry alias instead of retraining. Juniors are expected to put a model behind an endpoint and show how they would know it is up. From senior level the question becomes how they would know it is still right, and the design answer is judged on the numbers behind that: how stale a feature may be, how many milliseconds the prediction path can spend, and how much GPU memory quantizing the weights gives back.
[Python](/topics/lang-python) opens the plan for the code a pipeline runs, [Bash](/topics/lang-bash) for the entrypoints and glue between its steps, SQL for the data a model trains on. Linux follows, since every container and training node runs on it, then the [algorithms](/topics/found-dsa) a coding round may still ask for, and version control on Git and GitHub, which the GitOps module later treats as the source of truth for a cluster. HTTP and [gRPC](/topics/proto-grpc) come before any model, because a served model is an endpoint first, and its deadlines, streaming calls and health checks are protocol questions. The model then arrives as something to operate rather than design. [The frameworks](/topics/ai-ml-frameworks) sit ahead of the platform because packaging, scheduling and serving all depend on what PyTorch, TensorFlow or scikit-learn produced and needs at run time. Containers follow, from the isolation model through Docker to [Kubernetes](/topics/cloud-kubernetes), and delivery comes after the runtime it delivers to: pipeline concepts, [GitOps](/topics/cloud-cicd-gitops) reconciling a cluster to a repository, and infrastructure as code underneath. The cloud stretch rents the hardware and adds the first infrastructure made for ML: the Hugging Face Hub's revisions as a source of pinned weights, and [distributed training](/topics/ai-distributed-training), where DDP and sharding lean on the framework module and GPU scheduling on the Kubernetes one. Data follows compute. The storage module runs from relational and analytical concepts to [vector stores](/topics/db-vector-concepts) operated as infrastructure: how an index is sharded and replicated, whether a lost one is restored from a snapshot or rebuilt from source, and how long a write takes to become searchable. [Processing engine concepts](/topics/data-processing-concepts) then describe the job that builds a training set: how it splits the work, why one hot key stalls it and how it survives a lost worker. [Orchestration](/topics/data-orchestration) then puts a retraining job on a schedule, and broker operations cover the streams a model may read at prediction time. From testing on, the plan keeps a running system honest: the testing module ends on [AI-powered features](/topics/found-testing-ai-systems), whose varying output needs a different kind of assertion, and observability runs from the signals through [OpenTelemetry](/topics/cloud-opentelemetry) to [SRE practice](/topics/cloud-sre-practices), with [secret management](/topics/sec-secrets-mgmt-concepts) beside it because a training job holding a cloud credential is a workload like any other. The model's own lifecycle is placed after that on purpose: monitoring a model is ordinary metrics and traces with model signals added. MLflow promotes versions through [registry aliases](/topics/ai-mlflow-model-registry), [evaluation](/topics/found-ai-engineering-evaluation) scores output that has no single right answer and can hold a release back on a regression, [LLM tracing](/topics/found-ai-engineering-observability) records each model call as a span carrying its tokens and cost, and [interpretability](/topics/found-ml-fundamentals-interpretability) answers why a prediction came out as it did. Design at scale closes the technical plan: [ML system design](/topics/found-ml-system-design) as one section of general system design, [LLM inference serving](/topics/ai-serving) from continuous batching to KServe, and [quantization](/topics/found-llms-quantization), the memory arithmetic serving leans on. The module then steps back from the serving engine: the [LLM gateway](/topics/found-ai-engineering-llm-gateway) every team's model calls pass through for keys, spend caps and failover, then whether to [call a hosted model or serve open weights](/topics/found-ai-engineering-model-sourcing-hosted-vs-open) at all and, if open, [which rung to host them on](/topics/found-ai-engineering-model-sourcing-self-hosting-tradeoffs), from a managed endpoint to your own racks. The [behavioral round](/topics/found-behavioral) comes last.
Which half of the plan deserves your hours depends on which half you arrived with. From DevOps, SRE or platform work, the container, delivery and observability stretches are revision to sample; the time goes to the frameworks, distributed training, the model lifecycle and serving, where questions assume you know what a checkpoint, a collective or a KV cache is. From data science the profile is reversed, so switch study order to by topics, start at Linux and keep going at least through the CI/CD module; the lifecycle stretch will be the easy part. In the last days before a loop, rehearse one design story aloud from end to end, a model going from a tracked run to a registered version, a canary, a dashboard and a rollback, and drill only the questions still showing once the level range matches the posting's seniority and importance keeps only must know. With months ahead, add the depth that path skips: collectives and sharding, Kubernetes scheduling, the serving engines. The plan operates models more than it builds them. From ML fundamentals it takes interpretability alone; bias and variance, regularization and how one family of learner differs from another belong to the [Machine Learning Engineer roadmap](/roadmaps/machine-learning), the one to add if the role also trains the models. The LLM modules here serve, quantize and evaluate models; building retrieval and agent applications on top of them is the [AI Engineer roadmap](/roadmaps/ai-engineer)'s subject.
An MLOps loop usually looks like a platform engineering loop with a model inside it: a screen, a Python coding round that is as likely to be a data-validation script as an algorithm problem, one or two infrastructure conversations on containers, Kubernetes and delivery pipelines and, for anyone past junior, an ML system design round; the loop ends on behavioral questions.
The infrastructure questions tend to arrive as model problems. A training pod that requests nvidia.com/gpu stays Pending on a cluster with idle GPUs: is the device plugin advertising them, and does the pod tolerate the taint on the GPU nodes? A PyTorch image reinstalls every dependency on every commit: which Dockerfile line broke the cache? A job spread across several nodes hangs at its first all-reduce: which rank never joined the collective? A model promoted on Friday is worse by Monday and nothing has errored: did the inputs drift, is a feature computed one way in training and another at serving time, or have the labels simply not arrived yet?
Answers that score well treat a model as a build artifact with a lineage: the commit, data snapshot, locked dependencies and seed that produced it, and a rollback that moves a registry alias instead of retraining. Juniors are expected to put a model behind an endpoint and show how they would know it is up. From senior level the question becomes how they would know it is still right, and the design answer is judged on the numbers behind that: how stale a feature may be, how many milliseconds the prediction path can spend, and how much GPU memory quantizing the weights gives back.
Python opens the plan for the code a pipeline runs, Bash for the entrypoints and glue between its steps, SQL for the data a model trains on. Linux follows, since every container and training node runs on it, then the algorithms a coding round may still ask for, and version control on Git and GitHub, which the GitOps module later treats as the source of truth for a cluster. HTTP and gRPC come before any model, because a served model is an endpoint first, and its deadlines, streaming calls and health checks are protocol questions.
The model then arrives as something to operate rather than design. The frameworks sit ahead of the platform because packaging, scheduling and serving all depend on what PyTorch, TensorFlow or scikit-learn produced and needs at run time. Containers follow, from the isolation model through Docker to Kubernetes, and delivery comes after the runtime it delivers to: pipeline concepts, GitOps reconciling a cluster to a repository, and infrastructure as code underneath. The cloud stretch rents the hardware and adds the first infrastructure made for ML: the Hugging Face Hub's revisions as a source of pinned weights, and distributed training, where DDP and sharding lean on the framework module and GPU scheduling on the Kubernetes one.
Data follows compute. The storage module runs from relational and analytical concepts to vector stores operated as infrastructure: how an index is sharded and replicated, whether a lost one is restored from a snapshot or rebuilt from source, and how long a write takes to become searchable. Processing engine concepts then describe the job that builds a training set: how it splits the work, why one hot key stalls it and how it survives a lost worker. Orchestration then puts a retraining job on a schedule, and broker operations cover the streams a model may read at prediction time. From testing on, the plan keeps a running system honest: the testing module ends on AI-powered features, whose varying output needs a different kind of assertion, and observability runs from the signals through OpenTelemetry to SRE practice, with secret management beside it because a training job holding a cloud credential is a workload like any other.
The model's own lifecycle is placed after that on purpose: monitoring a model is ordinary metrics and traces with model signals added. MLflow promotes versions through registry aliases, evaluation scores output that has no single right answer and can hold a release back on a regression, LLM tracing records each model call as a span carrying its tokens and cost, and interpretability answers why a prediction came out as it did. Design at scale closes the technical plan: ML system design as one section of general system design, LLM inference serving from continuous batching to KServe, and quantization, the memory arithmetic serving leans on. The module then steps back from the serving engine: the LLM gateway every team's model calls pass through for keys, spend caps and failover, then whether to call a hosted model or serve open weights at all and, if open, which rung to host them on, from a managed endpoint to your own racks. The behavioral round comes last.
Which half of the plan deserves your hours depends on which half you arrived with. From DevOps, SRE or platform work, the container, delivery and observability stretches are revision to sample; the time goes to the frameworks, distributed training, the model lifecycle and serving, where questions assume you know what a checkpoint, a collective or a KV cache is. From data science the profile is reversed, so switch study order to by topics, start at Linux and keep going at least through the CI/CD module; the lifecycle stretch will be the easy part.
In the last days before a loop, rehearse one design story aloud from end to end, a model going from a tracked run to a registered version, a canary, a dashboard and a rollback, and drill only the questions still showing once the level range matches the posting's seniority and importance keeps only must know. With months ahead, add the depth that path skips: collectives and sharding, Kubernetes scheduling, the serving engines.
The plan operates models more than it builds them. From ML fundamentals it takes interpretability alone; bias and variance, regularization and how one family of learner differs from another belong to the Machine Learning Engineer roadmap, the one to add if the role also trains the models. The LLM modules here serve, quantize and evaluate models; building retrieval and agent applications on top of them is the AI Engineer roadmap's subject.