300-640 DCAI study plan

Map the end-to-end AI infrastructure stack (compute, fabric, storage, orchestration, security) into a one-page reference diagram you draw from memory

Compare GPU, TPU-class ASIC, and CPU-only node architectures on memory bandwidth, interconnect topology, and workload fit, and justify a choice for training versus inference

Calculate effective FLOPS and memory-bound throughput for a dense transformer layer given parameters, batch size, and precision, and identify the bottleneck

Size a training cluster (node count, GPU memory per node, aggregate HBM) for a stated model parameter count and precision

Diagram intra-node GPU interconnect (NVLink-class) versus inter-node fabric (InfiniBand/RoCE) and state where each latency and bandwidth constraint binds

Compute all-reduce and all-to-all data volumes for ring and tree collectives at a given cluster size and explain how parallelism strategy changes traffic patterns

Distinguish data, tensor, pipeline, and expert parallelism by their communication footprint and failure modes

Select a fabric technology for a stated job (small dense training, MoE inference, multi-tenant fine-tuning) and defend the tradeoffs

Design a leaf-spine fabric for a specified GPU cluster size, choosing oversubscription ratio, port speed, and rail-optimized cabling

Explain congestion control and load balancing mechanisms (PFC, ECN, adaptive routing, multipath) and when each is required

Compare parallel file systems, object storage, and local NVMe tiers for checkpointing, dataset ingest, and model serving, and place each in a tiered data pipeline

Calculate checkpoint write bandwidth and storage capacity needs for a training job given model size, optimizer state, and checkpoint frequency

Design a data pipeline that keeps GPUs fed: ingest, sharding, caching, and prefetch, with the failure points identified

Compare cluster schedulers and orchestrators (Slurm-style HPC, Kubernetes with device plugins, gang scheduling) for AI workloads and pick one for a stated scenario

Describe how GPU sharing, queueing, and preemption affect utilization and job completion, and propose a policy that raises utilization without starving priority work

Automate a repeatable environment build (driver, CUDA, framework versions) using infrastructure-as-code or container images

Instrument a training job with metrics for GPU utilization, memory, fabric errors, and I/O wait, and define alert thresholds

Write a runbook for a stalled distributed job covering detection, triage order, and rollback

Explain capacity planning and chargeback/showback models for shared AI infrastructure

Trace a request through an inference serving path and identify autoscaling and batching levers

Model multi-tenant isolation for GPUs and fabric (partitioning, MIG-style slicing, tenant network segmentation) and state residual risks

Design a resiliency plan covering checkpoint recovery, node failure during training, and fabric link loss, with RTO targets

Quantify power and cooling constraints for a dense GPU rack and propose sustainability levers such as scheduling to renewable availability

Protect data in motion and at rest across the AI pipeline: encryption, key management, and access boundaries

Integrate prior weeks into one coherent reference architecture for a stated business requirement

Defend design decisions against cost, performance, and compliance objections in written form

Identify single points of failure and oversubscription hot spots in your own design and remediate them

Rehearse scenario-based design questions under time pressure across all six domains

Close weak spots by rebuilding the two weakest diagrams from memory without notes

Verify you can produce sizing math for compute, fabric, and storage without reference material