AI Training Cluster

Design the scheduler for a large GPU/TPU training cluster shared by multiple teams running distributed training jobs, handling gang scheduling, preemption, and failure recovery.

00

Practice checkpoints

The requirements are open as a taste. From the numbers onward, the full guide opens in the app.

  1. 01
    Clarify scope
  2. 02
    Requirements + scale
  3. 03
    API + data modelUnlocks in the app
  4. 04
    Draw architectureUnlocks in the app
  5. 05
    Deep diveUnlocks in the app
  6. 06
    Trade-off decisionUnlocks in the app
01

Requirements that shape the design

Do not only state requirements. Ask for them. Each card pairs the design constraint with a clarification question you can say out loud before drawing the architecture.

Functional requirements

01What runs here — one team’s pretraining, or everyone’s everything?

A shared cluster: many teams submit training, fine-tuning, and eval jobs — each with tenant, priority tier, GPU count, expected duration, and a checkpoint policy the scheduler can read.

02A job asks for 512 GPUs and only 400 are free — start it partially?

Never: synchronous training moves in lockstep, so the gang launches all-or-nothing — the scheduler reserves freed GPUs toward the full set instead of leaking them to small jobs forever.

03Production needs capacity NOW and research is holding it — who wins?

Priority tiers: production preempts research, research preempts best-effort — and preemption is a contract: checkpoint signal, grace window, then reclaim, with the preempted job auto-requeued.

04Do teams get hard carve-outs, or one shared pool?

Fair-share quotas: each team owns a guaranteed share, but idle share is instantly backfillable by other teams’ preemptible jobs — capacity is loaned, never given away.

05A node dies four days into a two-week run — then what?

The whole gang halts (synchronous training cannot limp along), the scheduler swaps in a healthy node, and the job resumes from its last checkpoint — lost work is bounded by checkpoint cadence, not by luck.

06Where do training data and finished models live?

Datasets are staged onto node-local cache before launch so the input pipeline keeps GPUs fed; finished weights and checkpoints go to an artifact registry with lineage (job, data version, code version).

Out of scopeThe training code itself (parallelism strategy inside a job) · Online inference serving (a latency system, not a throughput one) · Data-center buildout — we respect rack power envelopes, we do not design them

Non-functional requirements

01What single number does the cluster owner wake up to?

Utilization of BUSY GPUs — allocated-but-idle counts as waste. At ~$2/GPU-hour, a 10,000-GPU cluster burns about $480K a day, so every stranded percent is real money.

02A job has waited six hours — can anyone say why?

Every scheduling decision is explainable — which constraint blocked placement (quota, gang size, topology, power envelope) — because an unexplainable queue destroys trust in shared infrastructure.

03How much work is one hardware failure allowed to destroy?

One failure destroys at most one checkpoint interval of work: cadence is derived from failure math (expected interruptions per day × GPU-hours per gap), not from a default config value.

04Can a 512-GPU job wait forever while small jobs keep landing?

The biggest job cannot starve behind a stream of small ones: gang reservations age, and the reserved-but-idle gap is backfilled only with preemptible work the scheduler can evict on time.

05What may telemetry record from other people’s training runs?

Telemetry records job metadata, GPU-hours, cost per tenant, and rack power/thermal headroom — never training data or model weights — because dense GPU racks hit the power envelope before they run out of space.

Keep asking — the interview is a conversation

Real interviews probe far more than a tidy list. These are the scope questions that separate candidates who interrogate the problem from those who recite it.

  • What is the job mix — a few 512-GPU pretraining runs, thousands of small fine-tunes, or both fighting for the same pool?
  • Which teams count as production, and who decides — is the preemption pecking order an org agreement before it becomes a scheduler feature?
  • How big are checkpoints, what write bandwidth do we have, and what restore time is acceptable?
  • Where does training data live today — can we stage it next to the GPUs, or must every job read across the network?
  • Are the racks power/cooling limited — is there capacity we can see on the floor but not actually power?
01

Unlock the full playbook for AI Training Cluster

Numbers, architecture diagram, API and data model, deep dives, expected topics, self-check, whiteboard starter, and common mistakes unlock inside the app.

02

Numbers that force architecture decisions

Locked in the app

03

Architecture path

Locked in the app

04

API and data model

Locked in the app

05

Deep dive directions

Locked in the app

+Series

Practice the related series