NCA-AMAD Cheat Sheet: High-Yield Facts for the NVIDIA AI Model and Application Development Exam

Free NCA-AMAD cheat sheet: high-yield facts for all 8 NVIDIA AI Model and Application Development exam domains, from agents, RAG and LoRA to inference, NIM, GPU sizing and physical AI.

This free interactive cheat sheet from FlashGenius is a quick-reference study guide with swipeable cards you can review on any device — no signup required.

NCA-AMAD Exam at a Glance

Exam: NVIDIA-Certified Associate: AI Model and Application Development (NCA-AMAD)
Format: 50-60 multiple-choice questions plus a hands-on lab, 1 hour
Scoring: pass or fail; NVIDIA does not publish a passing percentage or the lab tasks
Fee and validity: $125; valid 2 years, recertify by retaking the exam
Domains: 8, weighted as follows

Agentic AI (17%)
Data Processing and Data Flywheel (17%)
Inference Concepts (15%)
Model Customization and Fine-Tuning Concepts (14%)
Models and Model Types (11%)
NVIDIA AI Enterprise and Blueprints Overview (10%)
Physical AI (6%)
Sizing and Configuration (10%)

Practice with the 10-question NCA-AMAD quick start or the NCA-AMAD practice test hub.

Domain 1: Agentic AI (17%)

Exam tip: Read the trace or the setup before the options: the pattern (ReAct, planner-executor, reflection) and the weak point (an unchecked tool, missing memory, untrusted input) are usually visible there.

Agent vs single LLM call: A single call answers in one pass. An agent uses an LLM to plan, call tools, observe results and decide the next step in a loop until the task is done, with memory and guardrails around it.
Core building blocks: An agent combines an LLM (the reasoning engine), tools it can call, memory, a planning approach and an orchestration layer that runs the loop. The harness or runtime connects these pieces and executes the agent.
ReAct: Interleaves reasoning (Thought) with tool calls (Action) and their results (Observation), deciding each step from the last observation.
Planner-executor and reflection: Planner-executor writes a full plan first, then runs each step. Reflection has the model critique its own draft and revise it.
Tools and MCP: The Model Context Protocol (MCP) standardizes how agents discover and call tools served by MCP servers. NeMo Agent Toolkit can act as an MCP client; client and server transports (stdio, SSE or streamable HTTP) must match.
Short- vs long-term memory: Short-term memory is the current conversation in the context window. Long-term memory is stored outside the model and retrieved when needed, so facts survive across sessions.
Multi-agent systems: Specialized agents split a task (for example a researcher and a writer) under an orchestrator. Use them when sub-tasks need different tools or skills; a single agent is simpler when it can do the job.
Prompt injection: Text in retrieved documents, web pages or tool output that tries to give the model new instructions. Treat that content as untrusted data, limit tool permissions and gate sensitive actions with checks the model cannot bypass.
NeMo Guardrails rail types: Input rails (before the LLM), retrieval rails (filter retrieved chunks), dialog rails (conversation flow), execution rails (tool inputs and outputs) and output rails (response filtering and fact checking).
Human in the loop: Put human approval before irreversible or high-impact actions (payments, deletions, external messages), not on every low-risk step.
Agent metrics: Task completion rate, answer accuracy, tool-call correctness, steps per task, tokens and cost per task, and end-to-end latency. Multi-step workflows multiply token use and latency.
NVIDIA agent tools: NeMo Agent Toolkit builds, profiles and evaluates agent workflows and works with frameworks such as LangChain. NemoClaw is an alpha reference stack that runs supported AI agents inside NVIDIA OpenShell sandboxes with network policy and managed inference.

Practice Agentic AI questions

Domain 2: Data Processing and Data Flywheel (17%)

Exam tip: When production data is involved, the first step is almost always to curate it: remove PII, filter low-quality records and label outcomes before training or evaluating.

Structured, semi-structured, unstructured: Tables with a fixed schema are structured; JSON, XML and logs with self-describing fields are semi-structured; text, images, audio and video are unstructured.
GPU-accelerated data processing: RAPIDS cuDF speeds up pandas-style work on GPUs, and the RAPIDS Accelerator for Apache Spark runs Spark SQL and DataFrame jobs on GPUs. Gains are largest on heavy joins and aggregations over large data.
Data-quality issues: Missing values, duplicates and near-duplicates, stale records, label noise and class imbalance. Duplicates inflate some patterns and can leak test items into training.
Text preprocessing: Typical steps: language identification, cleaning and normalization, quality filtering, exact, fuzzy and semantic deduplication, PII removal and decontamination against evaluation sets.
Privacy and sovereignty: Remove or mask PII before training or logging, set retention limits, and keep data in the required region or on premises when sovereignty rules apply.
Lineage and provenance: Record which data, code, parameters and model versions produced a model so results can be audited and reproduced. This supports model risk management.
Evaluation datasets: Application-specific evaluation sets built from real tasks predict production quality better than general public benchmarks. Keep them separate from training data.
Data flywheel: A loop: collect production interactions and feedback, curate and label them, evaluate and customize models (fine-tuning or distillation), redeploy, and repeat. The NVIDIA Data Flywheel Blueprint uses this to find smaller models that match a larger one.
Batch vs streaming: Batch processes data in scheduled chunks and suits retraining and reports. Streaming (for example with Kafka) processes events as they arrive and suits real-time scoring and monitoring.
Production quality metrics: Accuracy, groundedness (answers supported by retrieved sources), hallucination rate and task completion, tracked over time on sampled live traffic.

Practice Data Processing and Data Flywheel questions

Domain 3: Inference Concepts (15%)

Exam tip: Decide which phase the symptom points to before picking a fix: slow first token means prefill, slow streaming means decode, and running out of memory at long context means KV cache.

Prefill vs decode: Prefill processes the whole prompt in parallel and builds the KV cache; it drives time to first token (TTFT) and is compute-bound. Decode generates one token at a time; it drives inter-token latency and is memory-bandwidth-bound.
Key metrics: TTFT (time to first token), ITL or TPOT (time between output tokens), end-to-end latency, throughput (tokens or requests per second) and concurrency. Report percentiles such as p95, not just averages.
KV cache: Stores keys and values for every token of every active sequence so they are not recomputed. Its size grows with context length times concurrent sequences, which is why long contexts cause out-of-memory errors.
Prefix caching: Reuses the KV cache for a shared prompt prefix, such as a common system prompt, across requests, cutting prefill time and TTFT.
Batching: Static batching waits for a full batch. In-flight (continuous) batching adds and removes requests at every step, keeping the GPU busy and raising throughput.
Quantization: Lower precision shrinks memory and speeds inference: FP16 or BF16 uses 2 bytes per parameter, FP8 or INT8 1 byte, FP4 or INT4 half a byte. Check accuracy on your own evaluation set after quantizing.
Speculative decoding: A small draft model (or extra heads) proposes several tokens and the large model verifies them in one pass, reducing latency when most drafts are accepted.
Tensor parallelism: Splits each layer across GPUs so a model too large for one GPU can run; it needs fast GPU-to-GPU links such as NVLink.
Disaggregated serving and NVIDIA Dynamo: Dynamo runs prefill and decode on separate workers so each can scale independently, adds KV-cache-aware routing, offloads KV cache across memory tiers and transfers it between nodes.
TensorRT-LLM and Triton: TensorRT-LLM optimizes LLM inference (in-flight batching, paged KV cache, quantization, speculative decoding). Triton Inference Server serves models with features such as dynamic batching.
Latency vs throughput: Larger batches raise throughput but also raise per-request latency. Choose the highest concurrency that still meets the latency target.
Cost drivers: Model size, input and output tokens, traffic volume, GPU type and the latency target. Cost per million tokens falls as throughput per GPU rises.

Practice Inference Concepts questions

Domain 4: Model Customization and Fine-Tuning Concepts (14%)

Exam tip: Climb the ladder in order: prompt engineering, then RAG for knowledge that changes or must be cited, then fine-tuning for a new behavior or format.

Prompt engineering: System prompts set role and rules; few-shot examples show the format; chain-of-thought asks for step-by-step reasoning; structured output (JSON schemas, guided decoding) makes responses machine-readable.
RAG pipeline: Ingest and parse documents, split into chunks, embed, index in a vector database, retrieve for each query, optionally rerank, then generate an answer grounded in the retrieved passages with citations.
Chunking: Chunks must fit the embedding model and keep related text together. Test chunk sizes and strategies (fixed, page-level, semantic) on your own questions.
Hybrid search and reranking: Hybrid search combines dense (semantic) and sparse keyword search such as BM25, which finds exact terms like part numbers. A reranker reorders the top candidates by relevance before generation.
Prompting vs RAG vs fine-tuning: Prompting is cheapest and fastest to try. RAG adds knowledge that changes or must be cited without retraining. Fine-tuning changes behavior, style or format and needs labeled data and compute.
SFT and instruction tuning: Supervised fine-tuning trains on prompt and ideal-response pairs; instruction tuning applies it across many tasks so the model follows instructions.
PEFT, LoRA and QLoRA: Parameter-efficient fine-tuning trains a small number of parameters. LoRA adds small low-rank matrices to frozen weights; QLoRA applies LoRA to a 4-bit quantized base model to save memory.
Preference optimization: RLHF trains a reward model from human preferences, then optimizes the policy against it. DPO learns directly from chosen-versus-rejected pairs. KTO uses single responses labeled good or bad. GRPO is a reinforcement-learning method that scores groups of sampled responses, often with verifiable rewards.
Distillation: Trains a smaller student model to imitate a larger teacher, cutting serving cost for a narrow task.
Risks: Catastrophic forgetting loses earlier abilities after fine-tuning; overfitting memorizes training data and fails on new inputs. Watch validation loss and re-run general evaluations.
Serving fine-tuned models: Serve LoRA adapters on a shared base model (NIM can load many adapters and select one by name in the request) or merge an adapter into the weights. Validate with offline tests, then A/B test before full rollout.

Practice Model Customization and Fine-Tuning Concepts questions

Domain 5: Models and Model Types (11%)

Exam tip: Pick the smallest model and the simplest model type that meets the requirement; cost per task usually decides between tiers.

Neural networks vs classical ML: Gradient-boosted trees and linear models often win on small tabular data; deep neural networks excel on unstructured data such as text, images and audio, and on very large datasets.
Why GPUs: Neural network training and inference are dominated by large matrix multiplications that run in parallel across thousands of GPU cores.
Tokens and context window: Models read and write tokens (pieces of words). The context window is the maximum number of tokens of input plus output a model can handle in one request.
Autoregressive generation: An LLM predicts the next token from all previous tokens, appends it and repeats.
Embeddings: Vectors that place similar meanings close together; embedding models power semantic search and RAG retrieval.
Model types: Base models continue text; instruction-tuned models follow instructions; reasoning models think step by step before answering; small language models trade some capability for speed and cost.
Mixture of experts: A router sends each token to a few expert sub-networks, so compute per token tracks the active parameters while memory must hold all experts.
Non-language models: Reranking models score query-passage relevance; vision-language models reason over images and text; omni models take several input types such as audio and video; world foundation models generate and predict physical-world video for robotics and simulation.
Computer vision tasks: Classification labels an image, object detection draws boxes, semantic segmentation labels every pixel by class, instance segmentation separates each object, and OCR reads text.
NVIDIA Nemotron: NVIDIA's open model family for agentic AI, offered in sizes (Nano, Super, Ultra) that trade cost for accuracy, plus related models for retrieval and safety.
Evaluation: Measure efficacy on task-specific data, robustness to noisy or adversarial inputs, and interpretability. LLM-as-a-judge scores open-ended outputs when there is no single correct answer.

Practice Models and Model Types questions

Domain 6: NVIDIA AI Enterprise and Blueprints Overview (10%)

Exam tip: If the question is about packaging and serving a model, think NIM; if it is about a ready-made reference application, think Blueprint; if it is about support and lifecycle, think NVIDIA AI Enterprise.

NVIDIA NIM: Prebuilt containers that package a model with an optimized inference engine and industry-standard, OpenAI-compatible APIs, so applications call it like any hosted LLM.
Running a NIM: A typical launch passes the NGC API key, mounts a host cache directory to /opt/nim/.cache so model files are not re-downloaded, maps port 8000 and exposes endpoints such as /v1/chat/completions.
NIM profiles: NIM selects an optimized profile (engine and precision) for the detected GPUs, so the same model can run on different hardware.
NVIDIA AI Enterprise: The software platform and support offering for production AI: NIM, NeMo and other frameworks with security patches, lifecycle management and enterprise support across cloud, data center, workstation and edge.
Branches: Production branches receive critical and high CVE patches monthly; long-term support branches receive them quarterly with up to three years of support, suiting environments that must re-validate rarely.
NVIDIA Blueprints: Reference architectures and sample code for common AI applications, such as RAG assistants, video search and summarization, and data flywheels, built on NIM and ready to customize.
Kubernetes deployment: Run NIM as containers on Kubernetes; the NIM Operator manages caching and deployment, and a Horizontal Pod Autoscaler can scale on custom metrics such as GPU KV cache usage via Prometheus.
Hybrid and self-hosted: The same container runs on premises, in any cloud or at the edge, and self-hosting keeps prompts and data inside your environment for data control.
AI Factory: NVIDIA's model for enterprise AI infrastructure: accelerated compute, networking and storage, a software platform (AI Enterprise and Kubernetes), models, and the applications and agents built on them.
Productivity use cases: Common LLM applications include enterprise search and RAG assistants, coding assistants, document summarization, customer-service agents and task-automation agents.

Practice NVIDIA AI Enterprise and Blueprints Overview questions

Domain 7: Physical AI (6%)

Exam tip: Map every workload to one of the three computers (train, simulate, run on the robot) and remember that more variety, not just more volume, closes the sim-to-real gap.

Physical AI: AI that perceives, reasons and acts in the physical world, such as robots, autonomous vehicles and smart spaces, as opposed to digital AI that only produces text, images or code.
The three computers: NVIDIA DGX trains the models; Omniverse and Cosmos on NVIDIA RTX PRO Servers simulate and generate synthetic data; Jetson AGX Thor runs the trained models on the robot.
Digital twins and Omniverse: Omniverse builds physically accurate virtual replicas of factories, warehouses and robots, using OpenUSD to describe and compose 3D scenes.
Isaac Sim and Isaac Lab: Isaac Sim simulates robots and sensors for testing and synthetic data; Isaac Lab trains robot policies, for example with reinforcement learning, in simulation.
Synthetic data: Generated, automatically labeled data for scenarios that are rare, dangerous or expensive to capture. Replicator in Isaac Sim scripts randomized scenes and writes labeled images.
Domain randomization: Varies lighting, textures, poses, camera angles and clutter so the real world looks like one more variation the model has already seen.
Sim-to-real gap and flywheel: Models trained in simulation can fail on real data. Close the gap by testing on real images, finding error patterns and changing what the simulation varies, then repeating.
NVIDIA Cosmos: World foundation models for physical AI: Cosmos Predict generates future video, Cosmos Transfer turns simulated or structured inputs into photorealistic variations, and Cosmos Reason is a reasoning vision language model; Cosmos also provides data curation tools.
Isaac GR00T: Isaac GR00T N1 is an open foundation model for generalist humanoid robot skills. It takes camera images, a language instruction and the robot's state, and it is post-trained with real or synthetic data for a specific robot.

Practice Physical AI questions

Domain 8: Sizing and Configuration (10%)

Exam tip: Do the memory math first: weights are parameters times bytes per parameter, then KV cache grows with context length times concurrent sequences.

Weight memory: Parameters times bytes per parameter: a 70-billion-parameter model needs about 140 GB in FP16, 70 GB in FP8 and 35 GB in 4-bit, before KV cache and runtime overhead.
KV cache memory: Grows with context length times concurrent sequences. Doubling either roughly doubles KV cache memory.
Replicas and scaling: Horizontal scaling adds replicas to serve more users; vertical scaling uses bigger or more GPUs per replica. Requests in flight equal request rate times time per request.
Key settings: Maximum batch size, maximum sequence length (context), precision, and the share of GPU memory the server may use. Higher batch size raises throughput and memory use; longer context raises KV cache per request.
Run:ai: Pools GPUs across teams and schedules workloads with quotas and priorities, including fractional GPU sharing, to raise utilization.
Model lifecycle: Version the model, prompts and data together; retrain or fine-tune when monitoring shows drift or new requirements; release with staged rollouts and keep the previous version ready for rollback.
Monitoring and SLAs: Track latency percentiles, throughput, error and timeout rates, GPU utilization and memory, and quality signals. Alert when a service-level objective is at risk.
MTTD and MTTR: Mean time to detect measures how long a problem goes unnoticed; mean time to repair measures how long it takes to fix once detected. Better alerting cuts MTTD; tested runbooks and fast rollback cut MTTR.
Drift and anomaly detection: Data drift is a change in inputs; concept drift is a change in the input-to-outcome relationship. Compare live feature distributions with the training baseline, especially when labels arrive late.
Observability and tracing: Dashboards, logs, metrics and traces across prompts, agent steps, tool calls and retrieval show where latency and errors come from.
Runbooks and playbooks: A runbook gives step-by-step actions for a known operational task or incident; a playbook covers a broader response with roles and decisions. Automate tested runbook steps where possible.

Practice Sizing and Configuration questions

Last reviewed October 16, 2026 against the NVIDIA: AI Model and Application Development certification exam page. Technical facts come from the study resources NVIDIA lists for the exam.

FlashGenius is an independent study resource and is not affiliated with or endorsed by NVIDIA.

Open the interactive cheat sheet | All 50+ Free Certification Cheat Sheets | Free Practice Tests