NCP-GENL1 pageprintable

NVIDIA Certified Professional: Generative AI LLMs NCP-GENL Cheatsheet

Everything worth re-reading in the hour before you sit NCP-GENL, on one page. No explanations — just the facts, the weights, the traps and the judgement calls. Print it or keep it open beside your last practice run.

Exam facts

Credential
NVIDIA-Certified Professional: Generative AI LLMs
Exam code
NCP-GENL
Level
Professional (intermediate)
Duration
120 minutes
Questions
60–70
Passing score
70% (scaled score)
Price
$200 USD
Delivery
Online, remotely proctored, via Certiverse
Validity
2 years from issuance — recertify by retaking
Question format
Multiple choice and multi-select

Domain weights

  1. Model Optimization17%
  2. GPU Acceleration and Optimization14%
  3. Prompt Engineering13%
  4. Fine-Tuning13%
  5. Data Preparation9%
  6. Model Deployment9%
  7. Evaluation7%
  8. Production Monitoring and Reliability7%
  9. LLM Architecture6%
  10. Safety, Ethics, and Compliance5%

Study time follows weight. The top two domains are more than half the exam.

Exam-day tactics

  1. Pace at under two minutes a question. The paper can run to 70 questions in 120 minutes, so under two minutes each is the pace to rehearse. Flag anything still unresolved after a first pass and move on — a question you are stuck on costs you one you would have answered.
  2. Find the constraint before you eliminate. Applied questions name a constraint: latency, memory, accuracy, hardware, no retraining. Two options are usually right for the general subject and wrong for the stated constraint. Find the constraint clause first, then eliminate against it.
  3. Know the exact axis each parallelism mode splits. Tensor parallelism splits within a layer; pipeline parallelism splits across layers; sequence parallelism only applies when tensor-parallel size is greater than 1; expert parallelism is MoE-only. Naming the wrong axis is the domain's single most common miss.
  4. Separate what a technique costs from what it protects. Quantization, pruning, and distillation all trade some accuracy for memory or latency — none of them improve accuracy. When a question implies a technique is free, that is the tell that an option is wrong.
  5. Know each NVIDIA tool by its one job. NeMo Curator cleans data, ModelOpt and TensorRT optimize, Dynamo-Triton serves, NIM packages a served model as a microservice, NeMo Guardrails constrains. One clear sentence per tool resolves most platform questions.
  6. Measure readiness by your weakest domain, not the overall average. NVIDIA does not require passing every domain individually, but a strong overall average can still hide a domain you would fail on its own. Track results per domain and keep studying the lowest one, weighting Model Optimization and GPU Acceleration first.

One trap per domain

  • Model Optimization17%

    This is the single largest domain on the exam, and the density of confusable terms is the point: GPTQ is not a QAT variant and needs no labels, PTQ and QAT are not interchangeable at very low precision, and TensorRT optimizes while Triton (Domain 8) serves. Anchor every answer on the stated constraint — memory, latency, accuracy, or hardware — because that is what objective 4.2's "measure the accuracy tradeoff" is actually testing.

  • GPU Acceleration and Optimization14%

    Combined with Model Optimization, this domain is 31% of the exam — the material's own recommendation is to invest study time here first. The parallelism taxonomy is where most marks are lost: know precisely which axis each mode splits, since "tensor parallelism splits the batch" or "pipeline parallelism splits within a layer" are both wrong in a way the exam tests directly.

  • Prompt Engineering13%

    The phrase "adapting an LLM" makes this sound purely mechanical, but the professional-level test is judgment under constraint: small dataset, specialized domain, strict output format, or the choice between prompting and fine-tuning. Output validation reduces hallucination risk but does not make the base model more knowledgeable — that requires grounding it with RAG, not a better wrapper.

  • Fine-Tuning13%

    This domain is full of "which method has which property" distractors, and DPO is the sharpest one: if an answer option describes DPO as training a reward model and then running PPO, it is describing classic RLHF, not DPO. A close second is treating P-tuning, adapters, and LoRA as interchangeable PEFT — they differ in what they add and whether it can be merged away at inference time.

  • Data Preparation9%

    Perplexity comparisons across two models are only valid when both use the same tokenizer, since tokenization changes token counts directly — a distractor that connects this domain straight into Evaluation. A second standing trap: treating "remove all the jargon" as good data hygiene, when a custom tokenizer that preserves domain terms is almost always the better answer.

  • Model Deployment9%

    NIM and Dynamo-Triton get treated as interchangeable, and they are not: NIM is the higher-level, prepackaged, vLLM-backed microservice, and Dynamo-Triton is the general-purpose server it can sit on top of. A second common miss is applying dynamic batching logic to a stateful conversational model, when that scenario calls for sequence batching instead.

  • Evaluation7%

    This is a smaller domain by weight, but it is dense with trap pairs: BLEU-versus-ROUGE orientation, perplexity's direction and its blind spot for masked LMs, and faithfulness-versus-relevancy in RAG evaluation. Evaluating only the final answer text hides whether retrieval or generation produced the failure — the professional-level expectation is scoring the two stages separately.

  • Production Monitoring and Reliability7%

    The standing trap is treating a model that passed evaluation at launch as permanently validated — drift means live performance can decay silently as real-world inputs shift, and monitoring is what catches that, not the launch-time evaluation. A second miss is reporting only average latency, which hides exactly the tail requests that p95 and p99 exist to surface.

  • LLM Architecture6%

    This is the smallest domain by weight, but it is not shallow: expect to reason about why a mechanism exists and how it fails, not just name it. The most common miss is swapping Query and Value roles, or assuming embeddings only come from encoder models — decoders produce usable representations too, and objective 1.3 explicitly tests that.

  • Safety, Ethics, and Compliance5%

    The smallest domain by weight is also the easiest to underestimate: it sounds like a policy essay and is tested as engineering, with sharp, well-defined distinctions. The most common miss is assuming a guardrail "fixes" bias in the model — a guardrail constrains behavior at runtime; debiasing happens at the data and training level, and conflating the two costs marks.

Where the questions concentrate

The three subjects that carry the most marks in each domain.

Model Optimization17%

  1. Quantization
  2. KV caching as the primary latency lever for autoregressive decoding
  3. The DistilBERT trio

GPU Acceleration and Optimization14%

  1. Tensor parallelism (splits within a layer, intra-layer) versus pipeline parallelism (splits across layers, inter-layer)
  2. Sequence parallelism requiring tensor-parallel size greater than 1, and expert parallelism applying only to Mixture-of-Experts layers, not dense transformer layers
  3. ZeRO/FSDP as a memory-sharding technique for optimizer state layered on data parallelism, not a fifth parallelism family

Prompt Engineering13%

  1. In-context learning
  2. Chain-of-thought prompting
  3. Constrained decoding as a decoding-time control (valid JSON, a grammar, an enumerated set), distinct from any fine-tuning method

Fine-Tuning13%

  1. PEFT
  2. Alignment methods by their distinguishing property
  3. Catastrophic forgetting as the risk of full fine-tuning that PEFT is specifically designed to avoid

Data Preparation9%

  1. Tokenization
  2. The vocabulary-size tradeoff
  3. Fitting scalers and encoders on the training split only, since fitting on the full dataset leaks test information

Model Deployment9%

  1. Dynamic batching (stateless models, formed at runtime) versus sequence batching (stateful models, routed to the same instance)
  2. NIM as a prepackaged, containerized inference microservice
  3. Concurrent model execution and instance groups running multiple model copies in parallel on one GPU, complementing rather than duplicating dynamic batching

Evaluation7%

  1. Perplexity
  2. BLEU (precision-oriented, built for translation) versus ROUGE (recall-oriented, built for summarization)
  3. RAG evaluation metrics kept separate by what they measure

Production Monitoring and Reliability7%

  1. Latency percentiles (p95/p99) over averages, since a good mean can hide the tail behavior users actually feel
  2. Drift
  3. Monitoring versus evaluation as two separate activities

LLM Architecture6%

  1. Scaled dot-product attention
  2. Architecture-to-objective matching
  3. Embedding extraction from both encoder and decoder models, and cosine similarity as the comparison method, with query and document embeddings required to share one vector space

Safety, Ethics, and Compliance5%

  1. Bias detection via disaggregated, per-group evaluation, since a high overall accuracy number can mask disparate impact on a specific subgroup
  2. Guardrails constraining and steering model input and output at runtime, but not debiasing or retraining the underlying model
  3. RAG grounding reducing hallucination without eliminating it, since a model can still misuse or ignore the context it was given

Every NVIDIA tool by its one job

Most wrong options are a real product doing a job that belongs to a different one.

ToolIts jobNot for
NeMo CuratorCleans, deduplicates, and organizes LLM training data at scaleModel training or inference itself — it prepares the data that feeds them.
RAPIDS cuDFGPU-accelerated dataframe operations, a pandas-compatible acceleratorDeep learning — that is PyTorch or TensorFlow.
NVIDIA ModelOptPost-training quantization — FP8, INT8 SmoothQuant, INT4 AWQServing a model — it produces an optimized model that something else serves.
TensorRT / TensorRT-LLMCompiles and optimizes a model for a target GPU before serving — kernel fusion, precision calibrationServing traffic on its own — something else hosts the optimized engine.
Dynamo-TritonServes models in production across frameworks — dynamic batching, sequence batching, concurrent executionOptimizing the model itself. Triton runs what you give it.
NIM (NVIDIA Inference Microservices)A prepackaged, containerized microservice serving a curated model behind an OpenAI-compatible API — NIM LLM 2.0 is vLLM-backedBeing the model itself, or replacing Dynamo-Triton underneath it.
NeMo GuardrailsConstrains a deployed system at runtime across topical, safety/content, and security railsRemoving bias from a model. It bounds behavior; it does not retrain.

Metrics, and what each one hides

The exam asks which metric answers which question. The blind spot is the half most candidates cannot state.

MetricMeasuresUse whenBlind spot
PerplexityHow surprised a model is by text, derived from cross-entropy lossComparing two autoregressive models on the same corpus with the same tokenizerUndefined for masked LMs like BERT, and says nothing about accuracy or safety
BLEUModified n-gram precision against a reference, with a brevity penaltyMachine translation, or any task with a tight reference answerPunishes a correct paraphrase that uses different words
ROUGERecall-oriented overlap with a reference — ROUGE-N and ROUGE-LSummarization, where coverage of reference content matters mostA summary can score well while being incoherent
METEORAlignment with a reference allowing stems and synonyms, recall-weightedTranslation or generation tasks where pure n-gram overlap is too strictStill surface-level compared to an embedding-based score
BERTScoreSemantic similarity to a reference via contextual embeddingsYou want credit for a correct paraphrase that BLEU or ROUGE would missA high score does not guarantee factual correctness
Faithfulness (Ragas)Whether a generated answer is grounded in its retrieved contextEvaluating the generation half of a RAG pipeline specificallySays nothing about whether retrieval found the right context in the first place — pair with context precision/recall

Numbers worth knowing

120 min
Exam duration.
60–70
Questions on the paper.
70%
Passing score — a published scaled score, not overall per-domain.
17%
Model Optimization — the single largest domain.
31%
Model Optimization + GPU Acceleration combined — the material's own recommended priority.
175B → 3–4 bit
GPTQ can quantize a 175B-parameter model to 3–4 bits per weight in a few GPU hours.
~40% / ~60% / ~97%
DistilBERT: smaller, faster, and performance retained versus its teacher.
10,000x
LoRA's cut in trainable parameters versus full fine-tuning of GPT-3 175B.
2:4
Structured sparsity pattern that accelerates directly on Tensor Cores.
$200
Exam fee in USD, one attempt.
2 years
Validity. Recertify by retaking.

Acronyms

The fastest-decaying knowledge under exam pressure.

PTQ
Post-Training Quantization
QAT
Quantization-Aware Training
GPTQ
Generative Pre-trained Transformer Quantization
LoRA
Low-Rank Adaptation
PEFT
Parameter-Efficient Fine-Tuning
RLHF
Reinforcement Learning from Human Feedback
DPO
Direct Preference Optimization
GRPO
Group Relative Policy Optimization
KV cache
Key-Value cache
BPE
Byte-Pair Encoding
NIM
NVIDIA Inference Microservices
MIG
Multi-Instance GPU

If you only read four things

  1. Attention Is All You NeedVaswani et al., 2017 — the transformer
  2. GPTQ: Accurate Post-Training Quantization for Generative Pre-trained TransformersFrantar et al., 2022
  3. DistilBERT, a Distilled Version of BERT: Smaller, Faster, Cheaper and LighterSanh et al., 2019
  4. LoRA: Low-Rank Adaptation of Large Language ModelsHu et al., 2021

Ready for a timed run?

Sit a full-length mock at exam pace, or drill the domain you are weakest in.

Take a mock testPractise by domain