This plan is for someone who already builds with language models (calling an API, writing prompts, maybe a first RAG prototype) and can study about six to eight hours a week. It covers NVIDIA's eight NCA-AMAD sections in three weeks, grouped so that topics that depend on each other sit together, and leaves the fourth week for timed practice.
The reading comes from the suggested reading NVIDIA lists for each section on the NCA-AMAD certification page. NVIDIA's own sample questions cite NVIDIA blog posts and documentation for their answers, several of them from that reading list.
Before week 1: find where you stand
Answer a set of questions cold, before any reading. NVIDIA's sample questions on the certification page cover every section, and the 20 NCA-AMAD practice questions add more. If you already have the practice tests, take one under time instead.
Write down the sections where you missed questions. The plan below gives each group of sections a week, and your list tells you where to spend the extra hours inside each week.
Try 15 NCA-AMAD practice questions free
They come from the NCA-AMAD practice tests, and each option shows its explanation once you answer.
- 6 timed practice exams
- Every answer explained
- A score for each domain
- $19.99 one-time
Week 1: agents and data (34% of the exam)
Agentic AI and Data Processing and Data Flywheel are the two largest sections, at 17% each, and they connect: agents produce the logs and feedback that a data flywheel turns into better models.
Agentic AI. Learn the reasoning patterns (ReAct, ReWOO, reflection, planner-executor) and when each one breaks, how agents reach tools through APIs and MCP, short-term versus long-term memory, and the controls that keep an agent safe: input, retrieval, dialog, execution and output rails, plus human approval before irreversible actions. Learn how agent performance is measured: task success, steps and tokens per success, latency and cost.
- Introduction to LLM Agents
- Mastering Agentic Techniques: AI Agent Evaluation
- NeMo Guardrails rail types
- NVIDIA NeMo Agent Toolkit as an MCP client
Data Processing and Data Flywheel. Follow text from raw collection to a training set: Unicode fixing and language identification, heuristic filters, exact, fuzzy and semantic deduplication, and PII redaction. Add the data basics NVIDIA lists (structured versus unstructured data, feature stores, lineage, ETL with Spark and RAPIDS) and the flywheel loop: collect production data, curate it, customize, evaluate, deploy, repeat.
- Mastering LLM Techniques: Text Data Processing
- What Is a Data Flywheel? (NVIDIA glossary)
- Build Efficient AI Agents Through Model Distillation With the NVIDIA Data Flywheel Blueprint
- GPUs for ETL? Run Faster, Less Costly Workloads with NVIDIA RAPIDS Accelerator for Apache Spark and Databricks
Build an agent, then clean a dataset
Pick one or two in place of a reading session. The tool-loop lab is free with an account; the others come with Pro.
- Open labBuild an Agent From Scratch: The Tool Loop Without a Frameworkintermediate 80 minHosted
- Open labBuild a ReAct Agent with NVIDIA NIMintermediate 35 minHosted
- Open labBuild NeMo Guardrails for an AI Agent: Jailbreak & Topical Railsintermediate 35 minHosted
- Open labCurate a Fine-Tuning Dataset: Deduplicate, Filter, LLM-Judge and Balance Instruction Dataintermediate 50 minHosted
End of the week: answer questions 1 to 7 of the practice questions article and NVIDIA's samples for these two sections. Reread the explanation of every miss.
Week 2: inference and customization (29%)
Inference Concepts (15%) and Model Customization and Fine-Tuning Concepts (14%) cover most of the optimization and tuning techniques in the blueprint, and they share vocabulary: tokens, batches, adapters, latency.
Inference. Start with the two phases of LLM inference, prefill and decode, and the measures built on them: time to first token, inter-token latency and throughput. Then learn what each optimization changes: batching and in-flight batching, KV cache and prefix reuse, quantization, speculative decoding, tensor parallelism versus independent replicas, and disaggregated serving with NVIDIA Dynamo. Finish with serving operations: autoscaling, request queues and cold starts.
- LLM Inference Benchmarking: Fundamental Concepts
- Mastering LLM Techniques: Inference Optimization
- Introducing New KV Cache Reuse Optimizations in NVIDIA TensorRT-LLM
- Troubleshooting GPU memory errors in NIM for LLMs
Customization. The section asks when to prompt, when to retrieve and when to fine-tune. Cover prompt techniques (system prompts, few-shot, chain-of-thought, structured output), the RAG pipeline (chunking, embeddings, hybrid search, reranking), and the fine-tuning family: SFT, LoRA and QLoRA, RLHF, DPO and GRPO, distillation and instruction tuning. Learn the risks (catastrophic forgetting, overfitting) and how a tuned model ships: merged weights or adapters served on a shared base, checked offline and then in an A/B test.
- Mastering LLM Techniques: Customization
- RAG 101: Retrieval-Augmented Generation Questions Answered
- Seamlessly Deploying a Swarm of LoRA Adapters with NVIDIA NIM
- Enable Hybrid Search Support for the NVIDIA RAG Blueprint
Serve a model, quantize it, tune it, retrieve for it
The vLLM, quantization and LoRA labs run on NVIDIA GPU pods in the browser. The RAG lab on NVIDIA NIM is free with an account.
- Open labBuild a RAG Pipeline with NVIDIA NIMintermediate 35 minHosted
- Open labvLLM Production Serving: PagedAttention, Continuous Batching, Prefix Cachingadvanced 55 minGPU sandbox
- Open labQuantize & Optimize LLMs with bitsandbytesintermediate 40 minGPU sandbox
- Open labFine-Tune an LLM with LoRA and QLoRA (Jupyter)intermediate 45 minGPU sandbox
End of the week: take your first full practice test under time. Sort the misses by section and keep the list for week 4.
Three questions from the NCA-AMAD practice tests
Every request to a company assistant starts with the same 3,000-token system prompt and tool definitions, followed by a short user question of about 100 tokens. Time to first token is mostly spent processing that identical prefix on every call. Which optimization targets this directly?
[object Object]
Correct. TensorRT-LLM stores the KV cache blocks of completed requests and reuses them for later requests that share the same prefix. Only the new question tokens need prefill, which cuts TTFT and GPU work.
A. Shortening the prompt removes instructions the assistant relies on, and tool definitions are needed as input.
B. Lower precision makes each pass cheaper, yet the identical prefix is still recomputed on each call.
C. Batching processes the same prefix many times in parallel. The repeated work remains.
A team LoRA-tunes a model on 800 examples. With rank 8, held-out accuracy improves over the base model. With rank 128, training loss drops lower, but held-out accuracy falls below the rank-8 run. What explains the result?
[object Object]
Correct. NVIDIA notes that a smaller LoRA rank saves memory but may capture less task information, while a larger rank can lead to overfitting, and that rank 8 is already very effective as a starting point. With 800 examples, the extra capacity fits noise.
B. The lower training loss at rank 128 shows the adapter fits the training data even better.
C. Rank sets the adapter's size. The base weights stay frozen at any rank.
D. LoRA rank has nothing to do with tokenization, which belongs to the base model.
A team is building an instruction-tuning dataset from forum posts. Spot checks find hate speech, harassment and instructions for violence mixed into otherwise useful answers, and the team wants such content excluded before training. Which curation step fits?
[object Object]
Correct. NVIDIA's curation guidance uses domain and safety classification to filter harmful content; the AEGIS safety model classifies text into 13 critical risk categories, and classification can run distributed across GPUs at scale.
A. Deduplication removes repeats. A single copy of a harmful post would remain in the training data.
C. PII redaction protects personal information. Hate speech or violent instructions contain no PII to redact.
D. Language filtering keeps posts in the right language, harmful ones included. It does not judge content safety.
Full NCA-AMAD set: 6 timed exams, every answer explained, $19.99 one-time.
See the practice testsWeek 3: models, the NVIDIA platform, sizing and physical AI (37%)
Four smaller sections share this week: Models and Model Types (11%), NVIDIA AI Enterprise and Blueprints Overview (10%), Sizing and Configuration (10%) and Physical AI (6%). Their topic lists name specific NVIDIA products, so learn what each one is for.
Models. Know which model type does which job (embedding, reranking, vision-language, omni and world foundation models), the computer vision tasks, and the language-model variants: small versus large, base versus instruction-tuned, reasoning, open versus proprietary, dense versus mixture-of-experts. Review the mechanics too: tokens, context windows and autoregressive generation.
NVIDIA AI Enterprise and Blueprints. Learn what NVIDIA AI Enterprise includes and where it runs, what a NIM microservice packages and how it picks a configuration for the GPU, and how Blueprints serve as reference workflows you adapt. Add the deployment basics the topic list names: containers, Kubernetes, infrastructure as code and service meshes.
Sizing and Configuration. Practice the arithmetic (memory for weights and KV cache, replicas from per-replica capacity and peak traffic) and the operations vocabulary: latency percentiles and SLA breaches, MTTD and MTTR, GPU sharing with MIG, time-slicing and Run:ai, runbooks, and observability through logs, metrics and traces.
- Maximizing GPU Utilization with NVIDIA Run:ai and NVIDIA NIM
- Observability in the NVIDIA AI Factory for Government reference design
Physical AI. Learn the three-computer pattern (train, simulate, run on the robot), simulation and digital twins with Omniverse and Isaac Sim, synthetic data and domain randomization, and the two model families NVIDIA names: Cosmos and Isaac GR00T.
- What Is Physical AI? (NVIDIA glossary)
- Closing the Sim2Real Gap with NVIDIA Isaac Sim and NVIDIA Isaac Replicator
Run a vision-language model, deploy on Kubernetes, trace and share GPUs
Labs for the models, platform and sizing sections. Physical AI has no lab yet, so its reading carries that part of the week.
- Open labVisual Q&A with NVIDIA VLMsintermediate 30 minHosted
- Open labNVIDIA GPU Operator on k3s: Single-Node Kubernetes for GPU Workloadsintermediate 40 minGPU sandbox
- Open labLLM Observability: Trace, Cost and Debug a RAG Assistantintermediate 75 minHosted
- Open labGPU Sharing: Streams, MPS, MIG, and the Real Cost of Contentionadvanced 45 minGPU sandbox
End of the week: take a second timed practice test and compare the section scores with the first.
Week 4: timed practice and booking the exam
Alternate days: a timed practice test, then a day on the weakest section from that result, using the explanations of your misses and the reading for that section. Expect scores to move between sections from one test to the next, since a single test samples each section with only a few questions.
Book the exam once two practice tests you have not taken before both come back at 80% or higher. NVIDIA scores the exam pass/fail and does not publish a passing score, so the margin protects you from a hard draw of questions.
For the exam itself you need a Certiverse account. NVIDIA's exam details list a hands-on lab without describing it, as of October 2026, so read the certification page again in the last week for any update.
If your background is different
Serving and GPUs are new to you. Add a week between weeks 2 and 3 for inference and sizing. NVIDIA's recommended course, AI Model and Application Development Fundamentals, is an eight-hour instructor-led workshop that covers inference with NVIDIA Dynamo and running workloads with Kubernetes, Slurm and an observability stack.
Agents are new to you. Spend two extra sessions in week 1 building a small tool-calling agent with the NeMo Agent Toolkit or in the week 1 labs, so ReAct, tool descriptions and memory are things you have seen work.
You know machine learning well but not NVIDIA's stack. Keep the plan, and give week 3 more time: the questions there often turn on knowing what NIM, NeMo, Dynamo, Run:ai, Cosmos and Isaac GR00T each do.
Frequently asked questions
Is four weeks enough to prepare for NCA-AMAD?
This plan assumes it is for someone who already builds with language models and studies six to eight hours a week. If serving models on GPUs or building agents is new to you, add a week where your first practice test shows the most misses.
Do I need NVIDIA's course to pass NCA-AMAD?
The certification page recommends AI Model and Application Development Fundamentals, but the exam does not require it. The suggested reading for each section covers the same topics, and the course adds hands-on practice with an instructor.
Are there hands-on labs for NCA-AMAD?
Yes, with Preporato Pro: labs for agents, RAG, fine-tuning, LLM serving, data curation and monitoring, run in the browser with a check at every step. The ones that fit each week are listed in the plan above. NVIDIA's exam details list a hands-on lab without describing it (as of October 2026), so use the labs to practice the skills in NVIDIA's topic list. Physical AI has no lab yet.
Which NCA-AMAD section should I study first?
The two largest, Agentic AI and Data Processing and Data Flywheel, at 17% each. That is why they open this plan.
How many practice tests should I take before NCA-AMAD?
Take them until two tests you have not seen before both reach 80% or higher. In this plan that means one at the end of week 2, one at the end of week 3, and three or four in week 4.
Where can I find NCA-AMAD practice tests?
The NCA-AMAD practice tests overview lists what exists, starting with NVIDIA's own sample questions. The free questions on the certificate page come from the full preporato.com practice tests.
Sources: