One path. Every topic. Proof at every step.

Do: Read chapters 2, 5, 6, and 7; solve selected exercises rather than reading cover to cover.

Exit with: Explain vectors, gradients, probability, and optimization in model-training language.

Do: Complete the modules in order through datasets, generalization, classification, and production ML.

Exit with: Choose losses, splits, and metrics for a real prediction problem.

Do: Use the statistics and machine-learning playlists to repair concepts that remain unclear after the course.

Exit with: Teach bias/variance, regularization, trees, and common metrics without notes.

Do: Study leakage, inconsistent preprocessing, randomness, and pipeline safety before the lab.

Exit with: Build a leakage-safe experiment with a reproducible pipeline.

Do: Watch the foundations lecture and one domain lecture; write the forward and backward pass in your own words.

Exit with: Understand backpropagation, modern architectures, and training failure modes.

Do: Run every notebook from tensors through save/load, then rewrite the training loop without copying.

Exit with: Own an end-to-end PyTorch training and inference loop.

Do: Complete lessons 1–5 and reproduce one transfer-learning experiment with your own dataset.

Exit with: Move from a baseline to a measured, fine-tuned model.

Do: Add seeds, deterministic settings, environment capture, and checkpoint recovery to the project.

Exit with: Repeat an experiment and explain any remaining nondeterminism.

Do: Complete the tokenizer and GPT-building material; implement a tiny transformer rather than only watching.

Exit with: Explain tokens, attention, training, sampling, and inference from first principles.

Do: Study transformers, tokenizers, datasets, fine-tuning, and sharing; complete the exercises relevant to your capstone.

Exit with: Fine-tune or adapt a small model and document the compute/quality tradeoff.

Do: Follow foundations → augmented models → LLMOps → agents; convert each lecture into one testable system requirement.

Exit with: Design RAG and agent systems with evaluation and production constraints.

Do: Build one local MCP server with typed inputs and least-privilege tools.

Exit with: Explain hosts, clients, servers, transports, capabilities, and trust boundaries.

Do: Threat-model the RAG and agent projects; add prompt-injection and unsafe-tool tests.

Exit with: Demonstrate grounding, validation, approval gates, and bounded execution.

Do: Follow design → data → model → testing → reproducibility → production while applying each section to your project.

Exit with: Create a tested, reproducible ML repository rather than a notebook-only model.

Do: Prioritize infrastructure, testing, deployment, monitoring, data management, and continual learning lectures and labs.

Exit with: Connect training, serving, observability, and iteration into one lifecycle.

Do: Turn the rules into a design-review checklist for the service.

Exit with: Spot avoidable production and data-pipeline failure modes.

Do: Deploy locally, expose the service, scale it, update it, and perform a rollback.

Exit with: Explain deployments, services, health checks, scaling, and rollbacks.

Do: Study the lectures in order and use their iterative framework for every design.

Exit with: Frame objectives, data, models, infrastructure, monitoring, and iteration together.

Do: Work through four cases under a 45-minute limit, then revise each with peer or rubric feedback.

Exit with: Produce structured designs under interview constraints.

Do: Use the free online book as a reference for requirements, data, serving, monitoring, and technical debt.

Exit with: Recognize lifecycle and operational tradeoffs beyond model choice.

Do: Use the study plan selectively; pair each topic with timed problems and written complexity analysis.

Exit with: Solve common patterns clearly under time pressure.

Do: Use its coding, resume, behavioral, and negotiation sections to structure weekly practice.

Exit with: Run a complete interview loop rather than isolated coding practice.

Do: Answer questions aloud, tag weak areas, and link every strong answer to project evidence.

Exit with: Explain ML decisions precisely without hiding behind terminology.

Do: Complete fundamentals, object lifetime, move semantics, templates, smart pointers, and concurrency-relevant chapters.

Exit with: Write idiomatic C++ with explicit ownership and predictable lifetime.

Do: Complete shell, debugging/profiling, Git, and build-tool lectures using Linux.

Exit with: Navigate, debug, automate, and profile confidently from the terminal.

Do: Create a multi-target library, tests, install rules, and a release build.

Exit with: Own a reproducible native build instead of compiling ad hoc commands.

Do: Expose one C++ tensor or preprocessing operation to Python with tests and benchmarks.

Exit with: Reason about copies, ownership, exceptions, and the Python/C++ boundary.

Do: Complete the lessons and exercises on mapping, memory, communication, and GPU algorithms.

Exit with: Think in parallel decomposition before writing CUDA syntax.

Do: Study the programming model, memory hierarchy, execution model, streams, and performance guidance selectively.

Exit with: Explain how a kernel maps to hardware and memory transactions.

Do: Apply the APOD cycle—assess, parallelize, optimize, deploy—to every lab kernel.

Exit with: Prioritize optimizations using expected impact and measured bottlenecks.

Do: Capture a baseline, classify the bottleneck, change one factor, and compare profiles.

Exit with: Read occupancy, memory, instruction, and roofline evidence without guessing.

Do: Export with representative inputs, validate outputs, and inspect the graph and shape assumptions.

Exit with: Produce a valid ONNX artifact with a numerical parity test.

Do: Benchmark CPU and CUDA providers with warmup, stable inputs, I/O binding where relevant, and percentile latency.

Exit with: Compare runtimes without measurement mistakes.

Do: Follow the model-fit, runtime, execution-provider, measurement, and optimization flow.

Exit with: Evaluate whether a model and runtime fit an actual edge device.

Do: Complete the narrow end-to-end engine build before reading the broader API material.

Exit with: Verify the environment and understand the build → serialize → run loop.

Do: Follow ONNX conversion, runtime API, precision selection, and deployment workflows with your Phase 1 model.

Exit with: Build FP32 and FP16 engines and run them from Python and C++.

Do: Study explicit quantization and Q/DQ, then build INT8 only with a representative evaluation set.

Exit with: Quantize while measuring accuracy rather than assuming it is preserved.

Do: Use trtexec, profiling, streams, transfers, and batching guidance to find the real bottleneck.

Exit with: Create a reproducible performance report with controlled variables.

Do: Complete setup, JetPack, camera, and introductory edge-AI material for your exact Jetson model.

Exit with: Prepare, inspect, update, and recover the target device safely.

Do: Build pipelines, inspect caps, handle bus messages, and reason about clocks and buffering.

Exit with: Diagnose media-pipeline negotiation, buffering, and backpressure failures.

Do: Complete the Jetson quickstart, then study reference apps, latency measurement, metadata, containers, and tuning.

Exit with: Build an accelerated streaming inference pipeline using supported components.

Do: Use the setup and environment guides, then select one device-appropriate model tutorial.

Exit with: Run a reproducible device workload in a controlled container environment.

Do: Follow the fundamentals and one LLM/VLM tutorial that fits the memory of your target Jetson.

Exit with: Run a local model and understand its runtime, container, and memory requirements.

Do: Run two quantization levels, control context size, and measure prompt processing, generation, and peak memory.

Exit with: Explain how model format, quantization, context, and backend affect performance.

Do: Compare weight-only and activation-aware approaches conceptually, then document why the chosen method fits the device.

Exit with: Make a quality/memory/performance quantization decision.

Do: Use the Jetson and generative-AI playlists to reinforce deployment and optimization concepts for the selected stack.

Exit with: Connect model behavior to the NVIDIA edge runtime and hardware limits.

Do: Study roles, metadata, signatures, expiration, rollback protection, and key compromise recovery.

Exit with: Design a signed update chain that survives common repository attacks.

Do: Map its secure automotive update concepts to a general edge fleet and document what you keep or simplify.

Exit with: Design staged, compatible, recoverable device updates.

Do: Select relevant evasion, poisoning, privacy, and misuse threats and turn them into tests or controls.

Exit with: Threat-model model behavior as well as software delivery.

Do: Add provenance, integrity checks, and a verifiable build path for models and containers.

Exit with: Trace deployed artifacts back to controlled source and build steps.