← Frontier Lab Interview Curriculum·Study guide 09 of 13
Senior-staff study guide · 09

ML infrastructure: model distribution, data pipelines

ML infrastructure rounds ask you to move very large artifacts and data through a GPU fleet: ship a 400 GB checkpoint to thousands of hosts in minutes, keep 1,024 GPUs fed from object storage, and schedule and recover jobs on clusters where something fails every few hours. Anthropic's senior-staff infra loop used a coordinator-free model downloader; OpenAI and xAI ask about deployment reliability, preemptible job queues and 100K-GPU cluster management. A senior-staff candidate must derive the lower bound from bandwidth, pick chunking, fan-out and recovery designs with numbers, and know the failure rates and operational realities that published frontier-scale systems report.

67resources6courses2with video30from 2025–2651%advanced17/17question groups covered3%of interview evidence (4% at staff+)
Intro 7Core 26Advanced 34

The senior-staff bar

What L7-level depth looks like in this topic, the follow-up an interviewer would push on, and the resources that prepare you for it.

From the interview reportsThe Anthropic senior-staff infra loop's design round was a model downloader that recovers without a coordinator. Distributing large model files to thousands of machines recurs across staff reports.

Start here

The best resources for a time-poor senior engineer, newest first.

2026Book

Machine Learning Engineering Open Book

Stas Bekman · 2026 · ~20 h

Practitioner handbook from BLOOM/IDEFICS training: compute, storage, network benchmarking, fault tolerance, SLURM, debugging and checkpointing at scale.

2026Reference

Mosaic Streaming

MosaicML (Databricks) · 2026 · ~2 h

Streaming dataset format with deterministic, elastic shuffling and mid-epoch resumption across changing numbers of nodes.

2025Book

How To Scale Your Model

Jacob Austin, Sholto Douglas et al. (Google DeepMind) · Feb 2025 · ~15 h

Roofline analysis, TPU/GPU networking, parallelism strategies and serving maths for LLMs, written by DeepMind researchers.

2019Tool

Kraken: P2P Docker registry

Uber Engineering · Mar 2019 · ~3 h

Production P2P blob distribution (tens of TB, thousands of hosts) with content-addressed pieces, a tracker, origin cluster and bandwidth-aware peer selection.

Learning path

Work through the stages in order. The last stage is the senior-staff layer: production case studies, papers to critique and large-scale trade-offs. Each resource's L7 line says what it adds at your level.

  1. 1

    Numbers and vocabulary

    Do the bandwidth, memory and failure-rate arithmetic every design here needs · Week 1 (8–10 h)

    • 2025
      Jacob Austin, Sholto Douglas et al. (Google DeepMind) · Feb 2025 · Book · Advanced · ~15 h
      Roofline analysis, TPU/GPU networking, parallelism strategies and serving maths for LLMs, written by DeepMind researchers.
      L7Gives you the bandwidth and memory arithmetic (bytes/s per link, HBM, ICI/NVLink vs DCN) to put real numbers on any distribution or loader design.
    • 2025
      Nouamane Tazi et al. (Hugging Face) · Feb 2025 · Tutorial · Core · ~10 h
      Interactive guide to data, tensor, pipeline, context and expert parallelism with measured throughput on up to 512 GPUs.
      L7Baseline for the parallelism vocabulary interviewers assume; skim if you already know FSDP/TP/PP trade-offs.
    • 2026
      Amazon Web Services · 2026 · Reference · Core · ~0.5 h
      Per-prefix request rates (3,500 PUT / 5,500 GET per second), parallel ranged GETs, retries and scaling across prefixes.
      L7Gives the concrete object-storage limits that force you to add P2P or a cache tier when 5,000 hosts start at once.
    • 2008
      Bram Cohen (BitTorrent.org) · 2008 · Reference · Core · ~1 h
      Piece hashing, metainfo files, tracker protocol and peer wire protocol; the base vocabulary for chunked P2P distribution.
      L7Baseline; read it so piece size, rarest-first and tit-for-tat are concrete when you adapt them to a trusted datacenter.
    • 2026
      Hugging Face · 2026 · Reference · Intro · ~0.5 h
      Weight file format with a JSON header and zero-copy, memory-mapped loading.
      L7Baseline; know that headers allow parallel ranged reads per tensor or shard.
    • 2026
      NVIDIA · 2026 · Reference · Core · ~1 h
      Broadcast, all-gather and other collectives with ring/tree algorithms; the in-cluster alternative to P2P for weight fan-out.
      L7Lets you compare ring/tree broadcast bandwidth with P2P swarm and pick per network tier.
    • 2026
      Percy Liang, Tatsunori Hashimoto (Stanford) · Apr 2026 · Course · Core · ~40 h · video
      Builds an LM stack from tokenizer to distributed training; the systems, parallelism and data lectures show how training data and GPUs are kept busy.
      L7Watch the GPU, parallelism and data lectures; they let you reason about where loader or network bottlenecks sit in a real training step.
  2. 2

    Model and checkpoint distribution

    Design chunked, content-addressed, P2P/tree distribution with coordinator-free recovery · Week 2 (8–10 h)

  3. 3

    Data pipelines and checkpoints

    Build a loader that saturates GPUs and checkpoints that restore elastically · Week 3 (8–10 h)

    • 2026
      Thomas Breuel / WebDataset maintainers · 2026 · Tool · Core · ~1.5 h
      Tar-shard datasets read sequentially from object storage, with shard-level shuffling and buffer shuffles.
      L7Lets you explain why sequential shard reads beat random file reads at 1,024 GPUs and what shuffling quality you trade.
    • 2026
      MosaicML (Databricks) · 2026 · Reference · Core · ~2 h
      Streaming dataset format with deterministic, elastic shuffling and mid-epoch resumption across changing numbers of nodes.
      L7Lets you answer 'resume mid-epoch on a different node count with the same sample order' — a precise staff-level probe.
    • 2026
      PyTorch · 2026 · Reference · Intro · ~1 h
      Map vs iterable datasets, workers, samplers, pinned memory and prefetching.
      L7Baseline; skim if known. Know worker sharding for iterable datasets and DistributedSampler semantics.
    • 2026
      Meta / PyTorch · 2026 · Tool · Core · ~1 h
      Checkpointable data loader state and composable loading nodes for exact resumption.
      L7Lets you include loader state in the checkpoint so a restart neither repeats nor skips data.
    • 2026
      Anyscale / Ray · 2026 · Reference · Core · ~2 h
      Streaming execution across heterogeneous CPU/GPU workers for preprocessing and feeding training, with backpressure.
      L7Lets you describe a disaggregated preprocessing tier with backpressure into trainers.
    • 2026
      NVIDIA · 2026 · Reference · Intro · ~1 h
      GPU-accelerated decoding and augmentation to remove CPU bottlenecks in image/video pipelines.
      L7Baseline; mention when CPU decode is the bottleneck.
    • 2026
      PyTorch · 2026 · Reference · Core · ~1 h
      Sharded save/load with resharding across different world sizes, plus async saving.
      L7Lets you explain resharding on load (save on 1,024 GPUs, restore on 768) and async staging to CPU.
    • 2024
      PyTorch team (IBM, Meta) · Jun 2024 · Blog post · Core · ~0.5 h
      Measured checkpoint stall times for 7B–70B training before and after async DCP.
      L7Gives you numbers for the training stall each checkpoint costs, needed to argue checkpoint frequency.
  4. 4

    Cluster realities

    Scheduling, preemption, stragglers and failure handling on real fleets · Week 4 (8–10 h)

  5. 5

    Senior-staff depth

    Critique and cite frontier/hyperscale systems; run the 5,000-host and 1,024-GPU mocks · Weeks 4–6, interleaved (20–25 h)

    • 2022
      Jason Flinn et al. (Meta), OSDI · Jul 2022 · Paper · Advanced · ~3 h
      Meta's system for distributing hot binaries, models and packages to millions of hosts: P2P data plane with a centralized control plane and per-use-case policies.
      L7Lets you defend 'smart control plane, dumb peers' against fully decentralized designs with production numbers from Meta.
    • 2025
      Dingyan Zhang et al. (SJTU), OSDI · Jul 2025 · Paper · Advanced · ~2 h
      Loads weights from already-running instances over the compute network (RDMA/NVLink) instead of storage, multicast-style, during live scale-up.
      L7Lets you propose GPU-to-GPU weight transfer as the fast path and explain why storage bandwidth is the wrong bottleneck to fight.
    • 2024
      Yao Fu et al. (Edinburgh), OSDI · Jul 2024 · Paper · Advanced · ~2 h
      Fast multi-tier checkpoint loading (SSD/DRAM to GPU), a loading-optimized checkpoint format and locality-aware placement.
      L7Gives you numbers for the last hop (disk → GPU), which often dominates once the network is solved.
    • 2020
      Huiba Li et al. (Alibaba), USENIX ATC · Jul 2020 · Paper · Advanced · ~2 h
      Lazy, block-level image loading with P2P tree distribution across thousands of hosts at Alibaba.
      L7Lets you argue lazy loading vs full pre-pull and tree fan-out vs swarm for startup-latency-sensitive deploys.
    • 2002
      Petar Maymounkov, David Mazières, IPTPS · 2002 · Paper · Advanced · ~1.5 h
      XOR-distance DHT with k-buckets; how peers find who holds a chunk without any central tracker.
      L7Lets you answer 'the coordinator is gone, how do peers still find chunks?' with a mechanism rather than a hope.
    • 2023
      Andy Warfield (AWS), via Werner Vogels' blog · Jul 2023 · Blog post · Advanced · ~1 h
      How S3 spreads load over millions of drives, heat management and why per-object throughput is bounded.
      L7Lets you explain where object-storage throughput limits come from, not just quote them.
    • 2025
      DeepSeek · Feb 2025 · Tool · Advanced · ~2 h
      Disaggregated SSD + RDMA file system with CRAQ replication used for DeepSeek's training data, checkpoints and KV cache (multi-TB/s reads).
      L7A frontier-lab storage design you can cite when arguing a shared parallel FS vs object storage for training and checkpoints.
    • 2021
      Derek Murray et al. (Google), VLDB · Jan 2021 · Paper · Advanced · ~2 h
      Design and fleet-wide analysis of Google's input pipelines: parallelism autotuning, caching, prefetching and how often input is the bottleneck.
      L7Gives you data showing input-bound jobs are common and the levers that fix them, which grounds a 'keep GPUs fed' answer.
    • 2021
      Mark Zhao et al. (Meta), ISCA · Aug 2021 · Paper · Advanced · ~2 h
      Meta's disaggregated data preprocessing service: preprocessing can need more power than training, so it runs on separate CPU fleets.
      L7Lets you argue disaggregated preprocessing workers vs on-host DataLoader workers with Meta's numbers.
    • 2023
      Zhuang Wang et al. (Rice, AWS), SOSP · Oct 2023 · Paper · Advanced · ~2 h
      Checkpoints to peer CPU memory with placement and traffic scheduling so recovery is 13x faster than remote storage.
      L7Lets you propose in-memory peer checkpoints plus slower durable ones, and explain the correlated-failure risk.
    • 2025
      Borui Wan et al. (ByteDance), NSDI · Apr 2025 · Paper · Advanced · ~2 h
      Parallelism-agnostic checkpoint representation with automatic resharding and async I/O across ByteDance's training fleet.
      L7Gives production evidence for decoupling checkpoint layout from parallelism, a likely follow-up after 'how do you resume elastically?'.
    • 2024
      Ziheng Jiang et al. (ByteDance), NSDI 2024 · Feb 2024 · Paper · Advanced · ~3 h
      ByteDance's 12,288-GPU training system: diagnostics, straggler detection, fast checkpoint/recovery and network tuning, with incident data.
      L7Lets you discuss detection-to-recovery time at 10k+ GPUs with real numbers, which is the core of 100K-GPU cluster questions.
    • 2024
      Llama Team (Meta AI) · Jul 2024 · Paper · Advanced · ~3 h
      Section 3.3 covers the 16K-H100 cluster, storage (Tectonic, 2–7 TB/s checkpoint bursts), network and 466 job interruptions in 54 days with root causes.
      L7Lets you quote failure rates and checkpoint bandwidth from a real frontier run when sizing recovery.
    • 2024
      Apostolos Kokolis et al. (Meta) · Oct 2024 · Paper · Advanced · ~2 h
      Failure statistics from two Meta research clusters (24k+ GPUs), mean time to failure by job size and the effective training time ratio.
      L7Lets you predict how often a 4,096-GPU job will fail and set checkpoint cadence from that.
    • 2024
      Engineering at Meta · Jun 2024 · Blog post · Advanced · ~0.5 h
      Rolling maintenance of GPU clusters (firmware, kernels, drivers) in small slices while training continues, with consistency checks across hosts.
      L7Lets you describe landing infra changes on a live training fleet without stalling jobs.
    • 2016
      Ramesh Govindan et al. (Google), SIGCOMM · Aug 2016 · Paper · Advanced · ~2 h
      Analysis of 100+ Google network failures; most occur during management operations, leading to principles for safe change (canaries, rollback, drain).
      L7Gives you the evidence-based playbook for landing a fabric routing change safely.
    • 2015
      Abhishek Verma et al. (Google), EuroSys · Apr 2015 · Paper · Advanced · ~2 h
      Priorities, quotas, preemption, admission control and cell sizing in Google's cluster manager.
      L7Lets you design priority/quota/preemption semantics for a GPU job queue from a system that has run them for a decade.
    • 2021
      OpenAI · Jan 2021 · Blog post · Advanced · ~1 h
      OpenAI's large training clusters on Kubernetes: etcd, API server load, networking, gang scheduling and health checks for GPU nodes.
      L7Frontier-lab evidence for what breaks in Kubernetes at thousands of GPU nodes and how they patched it.
    • 2025
      Anthropic · Sep 2025 · Blog post · Advanced · ~0.5 h
      Three overlapping production bugs (context-window routing error, TPU misconfiguration, compiler bug) across hardware platforms, and changes to evaluation and detection.
      L7A frontier-lab example of why routing must only send traffic to correctly loaded, validated instances, and how hard detection is.

What the interviews ask

Problems that recur in this track across 21 reports (9 firsthand), with the resources that prepare you for each.

Question coverage

Every question group collected for this topic from candidate reports, mapped to the resources that prepare you for it. 17 of 17 groups are covered, which is 100% of all report mentions. Hover an example to see the full question.

ReportsQuestion group and examplePrepare with
5model weight distributionAnthropic 5 · 2 staff+Design a platform for shipping tens to hundreds of GB of model weights to a large number of GPU workers; observability when node capacity is…Kraken: P2P Docker registryOwl: Scale and Flexibility in Distribution of Hot ContentKubernetes Deployments and readiness probesA postmortem of three recent issuesP2P weight shipping, stuck-rollout observability, readiness-gated routing
1MLOpsAnthropic 1MLOps round (topic area named, no specific question given)Designing Machine Learning SystemsMade With MLFull Stack Deep Learning 2022MLOps lifecycle: data, training, deployment, monitoring
1network debugging role-playAnthropic 1Onsite prompt: role-play debugging a production compute job that has a networking problemMachine Learning Engineering Open BookNCCL collective operationsRoCE networks for distributed AI training at scaleNetwork benchmarking, NCCL troubleshooting, RoCE fabric failure modes
1P2P model distributionAnthropic 1Design a model downloader distributing a model to many machines where download and upload share a 10Gbps cap; argue the minimal time bound, …The BitTorrent Protocol Specification (BEP 3)Kraken: P2P Docker registryHow To Scale Your ModelShared-cap lower bound, then swarm/pipeline P2P design
1data loading for GPUsMistral 1Keeping GPUs supplied with data (efficient data-preparation pipeline)Mosaic StreamingUnderstanding Data Storage and Ingestion for Large-Scale Deep Recommendation Model Trainingtf.data: A Machine Learning Data Processing FrameworkWebDatasetSharded streaming, disaggregated preprocessing, prefetch and autotuning
1team-specific infra deep diveOpenAI 1Infrastructure interview: deep dive with a team member on a team-specific area expanding into system designMachine Learning Engineering Open BookMegaScale: Scaling Large Language Model Training to More Than 10,000 GPUsBroad infra depth to anchor a team-specific deep dive
1file distribution systemAnthropic 1System design (first round): a problem involving file sharing/distribution, where back-of-envelope math on throughput, latency, data size an…The BitTorrent Protocol Specification (BEP 3)Best practices design patterns: optimizing Amazon S3 performanceHow To Scale Your ModelThroughput and latency math driving distribution design
1deployment and pipeline reliabilityOpenAI 1System design focused on large-scale deployment and pipeline reliabilityGoogle SRE: Release EngineeringA postmortem of three recent issuesMaintaining large-scale AI capacity at MetaStaged rollouts, validation, pipeline reliability at fleet scale
1GPU training job queue with preemptionxAI 1System design: distributed job queue, training-queue flavored ("imagine 100k+ GPU jobs, some can be yanked mid-run"), with half the time on …Large-scale cluster management at Google with BorgKueue documentationGemini: Fast Failure Recovery in Distributed Training with In-Memory CheckpointsCheckFreq: Frequent, Fine-Grained DNN CheckpointingPriority queue, preemption signals, checkpoint-on-preempt trade-offs
1model distribution to GPU workersAnthropic 1Design a system to download and deploy a 500GB model to 100-1000 GPU workers (10 Gbps external, 10 Gbps per worker): minimize deployment tim…Kraken: P2P Docker registryNCCL collective operationsBest practices design patterns: optimizing Amazon S3 performanceBlitzScale: Fast and Live Large Model Autoscaling with O(1) Host Caching500 GB to 1,000 workers under 10 Gbps caps
1sharded model downloaderAnthropic 1Design a sharded model downloaderFrom Files to Chunks: Improving HF Storage EfficiencyKraken: P2P Docker registrysafetensors documentationChunk/shard sizing, content hashes, parallel ranged downloads
1model file distributionAnthropic 1 · 1 staff+Design a large model file distribution system.Owl: Scale and Flexibility in Distribution of Hot ContentDragonfly (CNCF) documentationDADI: Block-Level Image Service for Agile and Elastic Application DeploymentLarge-file distribution systems at Meta, Alibaba, CNCF
1GPU fleet job schedulingCohere 1How would you schedule jobs on a fleet of GPUs?Large-scale cluster management at Google with BorgSlurm Workload Manager documentationAnalysis of Large-Scale Multi-Tenant GPU Clusters for DNN Training WorkloadsMLaaS in the Wild: Workload Analysis and Scheduling in Large-Scale Heterogeneous GPU ClustersGang scheduling, locality, fragmentation, fair share
1multi-tenant fine-tuning serviceOpenAI 1Design a multi-tenant fine-tuning service.Announcing TinkerS-LoRA: Serving Thousands of Concurrent LoRA AdaptersMLaaS in the Wild: Workload Analysis and Scheduling in Large-Scale Heterogeneous GPU ClustersPooled GPUs for many tenants' LoRA jobs, isolation, sharing
1100K-GPU cluster managementxAI 1Design the training cluster management for 100K H100 GPUs with fault tolerance and elastic-scaling.MegaScale: Scaling Large Language Model Training to More Than 10,000 GPUsThe Llama 3 Herd of Models (infrastructure sections)Resiliency at Scale: Managing Google's TPUv4 Machine Learning SupercomputerNVIDIA Resiliency ExtensionFailure detection, fast recovery, elastic restarts at 10k+ GPUs
1datacenter fabric routing changexAI 1Walk through how you would land a routing change on a datacenter fabric spanning hundreds of thousands of GPUs without stalling a training r…Evolve or Die: High-Availability Design Principles Drawn from Google's Network InfrastructureJupiter Evolving: Transforming Google's Datacenter Network via Optical Circuit Switches and Software-Defined NetworkingMaintaining large-scale AI capacity at MetaSafe incremental fabric changes with drains, canaries, rollback
1GPU scheduling creditsAnthropic 1System design: implement a GPU scheduling system using credits (preemption, monopolization, node failures).Kueue documentationSlurm Workload Manager documentationLarge-scale cluster management at Google with BorgQuotas, borrowing, fair-share credits, preemption, node failure

All resources

Everything collected for this topic, newest first. 2026 items are marked green. ★ marks a top pick.

Type
Level
Subtopic

  • 2026
    Percy Liang, Tatsunori Hashimoto (Stanford) · Apr 2026 · Course · Core · ~40 h · video
    Builds an LM stack from tokenizer to distributed training; the systems, parallelism and data lectures show how training data and GPUs are kept busy.
    L7Watch the GPU, parallelism and data lectures; they let you reason about where loader or network bottlenecks sit in a real training step.
    Site shows Spring 2026; public videos are the 2025 offering.
  • 2026
    Tianqi Chen, Zhihao Jia (CMU) · Jan 2026 · Course · Core · ~30 h
    ML systems course covering frameworks, GPU programming, distributed training and LLM serving.
    L7Use for the distributed-training and serving lectures; recordings are not public.
    Spring 2026 offering; no public videos found.
  • 2026
    Stas Bekman · 2026 · Book · Advanced · ~20 h
    Practitioner handbook from BLOOM/IDEFICS training: compute, storage, network benchmarking, fault tolerance, SLURM, debugging and checkpointing at scale.
    L7Lets you speak from the failure modes real large runs hit (hung NCCL, slow nodes, full disks) instead of textbook ones.
    Continuously updated.
  • 2026
    Dragonfly maintainers (CNCF, originally Alibaba) · 2026 · Reference · Core · ~2 h
    P2P file and image distribution with a scheduler, seed peers and back-to-source; includes integrations for Hugging Face model downloads.
    L7Lets you compare a centrally scheduled P2P system with Kraken and BitTorrent and say which one recovers without a coordinator.
  • 2026
    Spegel maintainers · 2026 · Tool · Core · ~1 h
    P2P image sharing inside Kubernetes with no central state: nodes advertise layers they hold via a DHT and peers pull from each other.
    L7A small, readable example of coordinator-free distribution you can describe end to end.
  • 2026
    Hugging Face · 2026 · Reference · Intro · ~0.5 h
    Weight file format with a JSON header and zero-copy, memory-mapped loading.
    L7Baseline; know that headers allow parallel ranged reads per tensor or shard.
  • 2026
    NVIDIA · 2026 · Reference · Core · ~1 h
    Broadcast, all-gather and other collectives with ring/tree algorithms; the in-cluster alternative to P2P for weight fan-out.
    L7Lets you compare ring/tree broadcast bandwidth with P2P swarm and pick per network tier.
  • 2026
    Amazon Web Services · 2026 · Reference · Core · ~0.5 h
    Per-prefix request rates (3,500 PUT / 5,500 GET per second), parallel ranged GETs, retries and scaling across prefixes.
    L7Gives the concrete object-storage limits that force you to add P2P or a cache tier when 5,000 hosts start at once.
  • 2026
    Thomas Breuel / WebDataset maintainers · 2026 · Tool · Core · ~1.5 h
    Tar-shard datasets read sequentially from object storage, with shard-level shuffling and buffer shuffles.
    L7Lets you explain why sequential shard reads beat random file reads at 1,024 GPUs and what shuffling quality you trade.
  • 2026
    MosaicML (Databricks) · 2026 · Reference · Core · ~2 h
    Streaming dataset format with deterministic, elastic shuffling and mid-epoch resumption across changing numbers of nodes.
    L7Lets you answer 'resume mid-epoch on a different node count with the same sample order' — a precise staff-level probe.
  • 2026
    PyTorch · 2026 · Reference · Intro · ~1 h
    Map vs iterable datasets, workers, samplers, pinned memory and prefetching.
    L7Baseline; skim if known. Know worker sharding for iterable datasets and DistributedSampler semantics.
  • 2026
    Meta / PyTorch · 2026 · Tool · Core · ~1 h
    Checkpointable data loader state and composable loading nodes for exact resumption.
    L7Lets you include loader state in the checkpoint so a restart neither repeats nor skips data.
    Repo now lives under meta-pytorch/data.
  • 2026
    Anyscale / Ray · 2026 · Reference · Core · ~2 h
    Streaming execution across heterogeneous CPU/GPU workers for preprocessing and feeding training, with backpressure.
    L7Lets you describe a disaggregated preprocessing tier with backpressure into trainers.
  • 2026
    NVIDIA · 2026 · Reference · Intro · ~1 h
    GPU-accelerated decoding and augmentation to remove CPU bottlenecks in image/video pipelines.
    L7Baseline; mention when CPU decode is the bottleneck.
  • 2026
    PyTorch · 2026 · Reference · Core · ~1 h
    Sharded save/load with resharding across different world sizes, plus async saving.
    L7Lets you explain resharding on load (save on 1,024 GPUs, restore on 768) and async staging to CPU.
  • 2026
    NVIDIA · 2026 · Tool · Core · ~1 h
    Hang detection, in-job restart, straggler detection and local checkpointing for PyTorch/Megatron training.
    L7Shows concretely what 'detect a hung rank and restart in place' looks like in production tooling.
  • 2026
    Kubernetes project · 2026 · Reference · Core · ~1 h
    Priority classes, preemption and graceful termination semantics in Kubernetes.
    L7Baseline for preemption signals; know grace periods and how a trainer learns it is being evicted.
  • 2026
    Kubernetes SIG Scheduling · 2026 · Reference · Core · ~2 h
    Job queueing for Kubernetes: ClusterQueues with quotas, cohorts and borrowing, fair sharing, preemption and topology-aware scheduling.
    L7Lets you design quota/borrowing/credit semantics for a GPU job queue on a real API.
  • 2026
    SchedMD · 2026 · Reference · Core · ~2 h
    The scheduler most frontier training clusters use: partitions, multifactor priority, fair-share and preemption.
    L7Lets you compare HPC-style Slurm scheduling with Kubernetes for training and describe fair-share credits.
  • 2026
    Kubernetes project · 2026 · Reference · Intro · ~1 h
    Rolling updates, maxSurge/maxUnavailable, rollbacks and readiness gates.
    L7Baseline; use readiness to guarantee traffic only reaches instances that loaded the right weights.
  • 2026
    Anyscale / Ray · 2026 · Reference · Intro · ~1 h
    Distributed training orchestration with fault tolerance and checkpoint hooks on Ray.
    L7Baseline; an example orchestration layer for a fine-tuning service.
  • 2025
    Thinking Machines Lab · Oct 2025 · Blog post · Core · ~0.5 h
    A managed fine-tuning API where many users' LoRA jobs share pooled GPUs; describes the abstraction and what the service handles.
    L7Gives a frontier-lab reference product for a multi-tenant fine-tuning service and its API boundary.
  • 2025
    Anthropic · Sep 2025 · Blog post · Advanced · ~0.5 h
    Three overlapping production bugs (context-window routing error, TPU misconfiguration, compiler bug) across hardware platforms, and changes to evaluation and detection.
    L7A frontier-lab example of why routing must only send traffic to correctly loaded, validated instances, and how hard detection is.
  • 2025
    Dingyan Zhang et al. (SJTU), OSDI · Jul 2025 · Paper · Advanced · ~2 h
    Loads weights from already-running instances over the compute network (RDMA/NVLink) instead of storage, multicast-style, during live scale-up.
    L7Lets you propose GPU-to-GPU weight transfer as the fast path and explain why storage bandwidth is the wrong bottleneck to fight.
  • 2025
    Borui Wan et al. (ByteDance), NSDI · Apr 2025 · Paper · Advanced · ~2 h
    Parallelism-agnostic checkpoint representation with automatic resharding and async I/O across ByteDance's training fleet.
    L7Gives production evidence for decoupling checkpoint layout from parallelism, a likely follow-up after 'how do you resume elastically?'.
  • 2025
    Jacob Austin, Sholto Douglas et al. (Google DeepMind) · Feb 2025 · Book · Advanced · ~15 h
    Roofline analysis, TPU/GPU networking, parallelism strategies and serving maths for LLMs, written by DeepMind researchers.
    L7Gives you the bandwidth and memory arithmetic (bytes/s per link, HBM, ICI/NVLink vs DCN) to put real numbers on any distribution or loader design.
    Updated through 2026.
  • 2025
    Nouamane Tazi et al. (Hugging Face) · Feb 2025 · Tutorial · Core · ~10 h
    Interactive guide to data, tensor, pipeline, context and expert parallelism with measured throughput on up to 512 GPUs.
    L7Baseline for the parallelism vocabulary interviewers assume; skim if you already know FSDP/TP/PP trade-offs.
  • 2025
    DeepSeek · Feb 2025 · Tool · Advanced · ~2 h
    Disaggregated SSD + RDMA file system with CRAQ replication used for DeepSeek's training data, checkpoints and KV cache (multi-TB/s reads).
    L7A frontier-lab storage design you can cite when arguing a shared parallel FS vs object storage for training and checkpoints.
  • 2025
    Hao Zhang (UC San Diego) · Jan 2025 · Course · Core · ~30 h
    Lectures on GPUs, parallelization, collective communication, memory and LLM serving, with recordings linked from the site.
    L7The collective-communication and parallelization lectures support broadcast/all-gather arithmetic in distribution designs.
    Recordings hosted on podcast.ucsd.edu; access not verified.
  • 2025
    NVIDIA (Dynamo project) · 2025 · Tool · Core · ~1 h
    Rust service that caches model weights and moves them GPU-to-GPU from initialized replicas to new ones in a serving cluster.
    L7Shows how a current inference stack solves 'new replica needs 500 GB fast'; use it as a reference design.
    Date approximate.
  • 2024
    Hugging Face Xet team · Nov 2024 · Blog post · Core · ~0.5 h
    Content-defined chunking and chunk-level dedup for model files on the Hugging Face Hub.
    L7Lets you justify content-addressed chunks (dedup across versions, resumable, verifiable) as the unit of distribution.
  • 2024
    Wanchao Liang et al. (Meta), ICLR 2025 · Oct 2024 · Paper · Advanced · ~2 h
    PyTorch-native LLM training stack composing FSDP2, TP, PP, async DCP checkpointing and fault-tolerance hooks, with measured results.
    L7Lets you describe how checkpointing, parallelism and restarts fit in one modern training stack.
  • 2024
    Apostolos Kokolis et al. (Meta) · Oct 2024 · Paper · Advanced · ~2 h
    Failure statistics from two Meta research clusters (24k+ GPUs), mean time to failure by job size and the effective training time ratio.
    L7Lets you predict how often a 4,096-GPU job will fail and set checkpoint cadence from that.
  • 2024
    DeepSeek-AI · Aug 2024 · Paper · Advanced · ~2 h
    DeepSeek's 10,000-GPU cluster: network topology, HFReduce, 3FS storage and failure handling.
    L7Lets you discuss cost-driven cluster design trade-offs a frontier lab actually made.
  • 2024
    Engineering at Meta (SIGCOMM 2024) · Aug 2024 · Blog post · Advanced · ~1 h
    Meta's RoCE training fabric: topology, routing, congestion control and operational lessons from 24k-GPU clusters.
    L7Lets you reason about routing and congestion changes on an AI fabric and their effect on collectives.
  • 2024
    Yao Fu et al. (Edinburgh), OSDI · Jul 2024 · Paper · Advanced · ~2 h
    Fast multi-tier checkpoint loading (SSD/DRAM to GPU), a loading-optimized checkpoint format and locality-aware placement.
    L7Gives you numbers for the last hop (disk → GPU), which often dominates once the network is solved.
  • 2024
    Llama Team (Meta AI) · Jul 2024 · Paper · Advanced · ~3 h
    Section 3.3 covers the 16K-H100 cluster, storage (Tectonic, 2–7 TB/s checkpoint bursts), network and 466 job interruptions in 54 days with root causes.
    L7Lets you quote failure rates and checkpoint bandwidth from a real frontier run when sizing recovery.
    Read section 3.3 (Infrastructure, Scaling, and Efficiency).
  • 2024
    PyTorch team (IBM, Meta) · Jun 2024 · Blog post · Core · ~0.5 h
    Measured checkpoint stall times for 7B–70B training before and after async DCP.
    L7Gives you numbers for the training stall each checkpoint costs, needed to argue checkpoint frequency.
  • 2024
    Engineering at Meta · Jun 2024 · Blog post · Core · ~0.5 h
    Hardware reliability, fast recovery, efficient state preservation and network choices for Meta's GenAI training.
    L7Short frontier-scale framing of failure, recovery and checkpointing to open a cluster-management answer.
  • 2024
    Engineering at Meta · Jun 2024 · Blog post · Advanced · ~0.5 h
    Rolling maintenance of GPU clusters (firmware, kernels, drivers) in small slices while training continues, with consistency checks across hosts.
    L7Lets you describe landing infra changes on a live training fleet without stalling jobs.
  • 2024
    Yazhou Zu et al. (Google), NSDI · Apr 2024 · Paper · Advanced · ~2 h
    How Google's optical circuit switches and control plane route around failed TPU cubes and keep large slices available.
    L7Lets you discuss scheduling around failure domains and reconfigurable topology at Google scale.
  • 2024
    Ziheng Jiang et al. (ByteDance), NSDI 2024 · Feb 2024 · Paper · Advanced · ~3 h
    ByteDance's 12,288-GPU training system: diagnostics, straggler detection, fast checkpoint/recovery and network tuning, with incident data.
    L7Lets you discuss detection-to-recovery time at 10k+ GPUs with real numbers, which is the core of 100K-GPU cluster questions.
  • 2023
    Ying Sheng et al. (Berkeley, Stanford), MLSys 2024 · Nov 2023 · Paper · Advanced · ~2 h
    Unified paging of adapters and KV cache plus custom kernels to serve thousands of LoRA adapters on few GPUs.
    L7Lets you argue adapter-based multi-tenancy for fine-tuned models and its memory accounting.
  • 2023
    Zhuang Wang et al. (Rice, AWS), SOSP · Oct 2023 · Paper · Advanced · ~2 h
    Checkpoints to peer CPU memory with placement and traffic scheduling so recovery is 13x faster than remote storage.
    L7Lets you propose in-memory peer checkpoints plus slower durable ones, and explain the correlated-failure risk.
    ACM DOI 10.1145/3600006.3613145 is bot-blocked.
  • 2023
    Andy Warfield (AWS), via Werner Vogels' blog · Jul 2023 · Blog post · Advanced · ~1 h
    How S3 spreads load over millions of drives, heat management and why per-object throughput is bounded.
    L7Lets you explain where object-storage throughput limits come from, not just quote them.
  • 2023
    Goku Mohandas (Anyscale) · 2023 · Course · Intro · ~15 h
    Code-first MLOps course: data, distributed training and tuning with Ray, serving, CI/CD for models and monitoring.
    L7Baseline; gives a concrete pipeline to talk through in an MLOps round, not staff depth.
    Date approximate.
  • 2022
    Charles Frye, Sergey Karayev, Josh Tobin · Aug 2022 · Course · Intro · ~15 h · video
    Recorded lectures on data management, deployment, monitoring and ML teams.
    L7Baseline; skim if known. Useful only for an MLOps-named round.
  • 2022
    Leon Poutievski et al. (Google), SIGCOMM · Aug 2022 · Paper · Advanced · ~2 h
    How Google incrementally changes topology and routing of a live datacenter fabric with SDN and optical switches.
    L7Lets you describe incremental, drain-and-shift fabric changes without disrupting long-running jobs.
  • 2022
    Jason Flinn et al. (Meta), OSDI · Jul 2022 · Paper · Advanced · ~3 h
    Meta's system for distributing hot binaries, models and packages to millions of hosts: P2P data plane with a centralized control plane and per-use-case policies.
    L7Lets you defend 'smart control plane, dumb peers' against fully decentralized designs with production numbers from Meta.
  • 2022
    Chip Huyen (O'Reilly) · May 2022 · Book · Core · ~12 h · paid
    End-to-end ML system design: data pipelines, feature stores, deployment, monitoring and continual learning.
    L7Mid-level MLOps coverage; read the data and deployment chapters for an 'MLOps round', skip the rest.
    Paid book.
  • 2022
    Assaf Eisenman et al. (Meta), NSDI · Apr 2022 · Paper · Advanced · ~1.5 h
    Incremental and quantized checkpoints for TB-scale recommendation models at Meta.
    L7Lets you cut checkpoint bandwidth with differential checkpoints and discuss correctness of quantized restores.
  • 2022
    Qizhen Weng et al. (Alibaba), NSDI · Apr 2022 · Paper · Advanced · ~1.5 h
    Two-month trace of Alibaba's 6,000-GPU cluster: GPU sharing, fragmentation and scheduling policies.
    L7Lets you discuss fragmentation and fractional GPU sharing in multi-tenant fine-tuning or job queues.
  • 2022
    Chip Huyen (Stanford) · Jan 2022 · Course · Core · ~20 h
    Course on production ML systems: data engineering, training data, deployment, monitoring and infrastructure, with slides and notes.
    L7Baseline MLOps structure; lectures are not public, so use the notes for vocabulary only.
    Winter 2022 is the latest offering; lecture videos were not publicly released.
  • 2021
    Mark Zhao et al. (Meta), ISCA · Aug 2021 · Paper · Advanced · ~2 h
    Meta's disaggregated data preprocessing service: preprocessing can need more power than training, so it runs on separate CPU fleets.
    L7Lets you argue disaggregated preprocessing workers vs on-host DataLoader workers with Meta's numbers.
  • 2021
    Satadru Pan et al. (Meta), FAST · Feb 2021 · Paper · Advanced · ~2 h
    Exabyte-scale multitenant filesystem at Meta, including how data warehouse and blob workloads share one cluster.
    L7Lets you discuss multitenant storage isolation for training data and checkpoints at hyperscale.
  • 2021
    Jayashree Mohan et al. (UT Austin, Microsoft), FAST · Feb 2021 · Paper · Advanced · ~1.5 h
    Two-phase snapshot/persist checkpointing with frequency tuned to keep overhead bounded.
    L7Lets you derive checkpoint interval from failure rate and stall cost, instead of picking 'every hour'.
  • 2021
    Derek Murray et al. (Google), VLDB · Jan 2021 · Paper · Advanced · ~2 h
    Design and fleet-wide analysis of Google's input pipelines: parallelism autotuning, caching, prefetching and how often input is the bottleneck.
    L7Gives you data showing input-bound jobs are common and the levers that fix them, which grounds a 'keep GPUs fed' answer.
  • 2021
    OpenAI · Jan 2021 · Blog post · Advanced · ~1 h
    OpenAI's large training clusters on Kubernetes: etcd, API server load, networking, gang scheduling and health checks for GPU nodes.
    L7Frontier-lab evidence for what breaks in Kubernetes at thousands of GPU nodes and how they patched it.
    openai.com blocks curl.
  • 2020
    Huiba Li et al. (Alibaba), USENIX ATC · Jul 2020 · Paper · Advanced · ~2 h
    Lazy, block-level image loading with P2P tree distribution across thousands of hosts at Alibaba.
    L7Lets you argue lazy loading vs full pre-pull and tree fan-out vs swarm for startup-latency-sensitive deploys.
  • 2019
    Myeongjae Jeon et al. (Microsoft), USENIX ATC · Jul 2019 · Paper · Advanced · ~1.5 h
    Trace study of Microsoft's Philly cluster: gang scheduling, locality vs queueing delay and failure causes.
    L7Gives evidence for the locality-vs-wait trade-off when you design GPU queue placement.
  • 2019
    Uber Engineering · Mar 2019 · Tool · Advanced · ~3 h
    Production P2P blob distribution (tens of TB, thousands of hosts) with content-addressed pieces, a tracker, origin cluster and bandwidth-aware peer selection.
    L7The closest open design to the interview prompt; lets you argue tracker vs DHT, origin rate limits and piece size with a real system.
    Uber's announcement blog blocks curl (406); the repo README and docs carry the architecture.
  • 2016
    Ramesh Govindan et al. (Google), SIGCOMM · Aug 2016 · Paper · Advanced · ~2 h
    Analysis of 100+ Google network failures; most occur during management operations, leading to principles for safe change (canaries, rollback, drain).
    L7Gives you the evidence-based playbook for landing a fabric routing change safely.
  • 2016
    Google · 2016 · Book · Core · ~1 h
    Hermetic builds, staged rollouts, canaries and configuration management.
    L7Lets you structure a staged weight rollout with canaries and automatic rollback.
  • 2015
    Abhishek Verma et al. (Google), EuroSys · Apr 2015 · Paper · Advanced · ~2 h
    Priorities, quotas, preemption, admission control and cell sizing in Google's cluster manager.
    L7Lets you design priority/quota/preemption semantics for a GPU job queue from a system that has run them for a decade.
    Older but canonical.
  • 2013
    Malte Schwarzkopf et al. (Google), EuroSys · Apr 2013 · Paper · Advanced · ~2 h
    Shared-state optimistic concurrency scheduling vs monolithic and two-level schedulers.
    L7Lets you argue scheduler architecture for 100k-GPU fleets: one scheduler, many with conflicts, or two-level.
    Older but canonical.
  • 2008
    Bram Cohen (BitTorrent.org) · 2008 · Reference · Core · ~1 h
    Piece hashing, metainfo files, tracker protocol and peer wire protocol; the base vocabulary for chunked P2P distribution.
    L7Baseline; read it so piece size, rarest-first and tit-for-tat are concrete when you adapt them to a trusted datacenter.
    Older but canonical.
  • 2002
    Petar Maymounkov, David Mazières, IPTPS · 2002 · Paper · Advanced · ~1.5 h
    XOR-distance DHT with k-buckets; how peers find who holds a chunk without any central tracker.
    L7Lets you answer 'the coordinator is gone, how do peers still find chunks?' with a mechanism rather than a hope.
    Older but canonical.
Not found or not verified. No Anthropic or OpenAI engineering post on distributing model weights was found; Meta's Owl (OSDI'22) is the only frontier/hyperscale first-party paper on the problem. Uber's Kraken announcement blog blocks curl (406), so the GitHub repo stands in. No 2025–2026 MLOps course with public videos was found: Stanford CS329S last ran Winter 2022 without public recordings, CMU 15-442 (Spring 2026) has no public videos, and UCSD CSE 234 recordings are on podcast.ucsd.edu with access not checked. OpenAI pages (Kubernetes 7,500 nodes) return 403 to curl and are marked exists-per-search. Nothing public on xAI's 100K-GPU cluster management; MegaScale, Llama 3 and Google TPUv4 resiliency stand in. GPU 'credits' scheduling has no single write-up; covered by Kueue fair sharing/borrowing and Slurm fair-share. The ACM page for the Gemini (SOSP'23) paper is bot-blocked; Amazon Science page and PDF used instead. Links checked 27 Oct 2026.