NCA-GENLNVIDIAAssociate

NVIDIA Certified Associate: Generative AI LLMs NCA-GENL Exam Guide

NCA-GENL is an entry-level, remotely proctored certification for developers who build with generative AI and large language models. It is pitched at the associate level: you are expected to work competently on an LLM system with senior oversight, choosing sensible tools and knowing when to escalate, rather than architecting one from scratch. The exam is broad rather than deep — 50 to 60 questions in an hour, spanning machine-learning fundamentals, transformer architecture, retrieval-augmented generation, Python NLP tooling, model serving, evaluation methodology, and trustworthy-AI practice.

Written and reviewed by Alex Mercer, Senior Generative AI Solutions Architect

Exam facts

The mechanics of the exam, and how the five domains divide the marks between them.

Credential
NVIDIA-Certified Associate: Generative AI LLMs
Exam code
NCA-GENL
Level
Associate (entry-level)
Duration
60 minutes
Questions
50–60

Plan for 60 and pace at one minute each, so a shorter paper leaves you time to review.

Passing score
Not published

NVIDIA does not disclose a cut score. Judge readiness by consistent results across all five domains instead.

Price
$125 USD
Delivery
Online, remotely proctored
Validity
2 years — recertify by retaking
Question format
Multiple choice

A quarter are "Select TWO", which need exactly two answers and give no partial credit.

Where the marks are

study in this order

  1. Core Machine Learning and AI Knowledge
    30%
  2. Software Development
    24%
  3. Experimentation
    22%
  4. Data Analysis and Visualization
    14%
  5. Trustworthy AI
    10%

Weights translate directly into study hours. Core Machine Learning and AI Knowledge is nearly a third of the exam and underpins everything else, so it earns the most time. Software Development and Experimentation together are almost half. Data Analysis and Trustworthy AI are smaller, but both are cheap to prepare — a focused afternoon each covers most of what they ask, which makes them the best return per hour on the whole exam.

Domains

Each domain in weight order: what it covers, what you need to be able to do, where the questions actually concentrate, and the mistake to avoid.

Core Machine Learning and AI Knowledge

30%

of the exam

The algorithms, architectures and techniques behind machine learning and large language models — and the judgement to pick between them for a stated task.

What you need to be able to do

  • Understand the fundamentals of machine learning, including feature engineering, model comparison and cross-validation
  • Explain how transformers and the attention mechanism work, and what they buy you over earlier architectures
  • Build LLM applications such as retrieval-augmented generation, chatbots and summarizers
  • Curate and embed content datasets for retrieval
  • Select and use models to create text embeddings
  • Apply prompt-engineering principles to get a desired result
  • Use Python NLP packages — spaCy, NumPy, Keras, vector databases — to implement analyses
  • Read research papers to keep up with emerging LLM techniques
  • Assist with deploying models and evaluating their scalability, performance and reliability

Where the questions concentrate

  1. Transformer architecture and the attention mechanism — the single densest subject on the exam. Self-attention versus recurrence, multi-head attention, positional encoding, encoder-decoder versus decoder-only, and what each design choice buys you
  2. Embeddings: dense versus sparse, bi-encoder models, cosine similarity, dimensionality trade-offs, and choosing an embedding model for a stated retrieval task
  3. Retrieval-augmented generation end to end — chunking, indexing, retrieval, generation — and diagnosing which stage produced a bad answer
  4. Prompt engineering: zero-shot and few-shot, chain-of-thought, role and delimiter discipline, and why an instruction-tuned model behaves differently from a base model
  5. Fine-tuning and parameter-efficient adaptation, with LoRA treated as core associate-level knowledge rather than an advanced topic
  6. Tokenization: byte-pair encoding, WordPiece and SentencePiece, and how token boundaries affect cost estimates
  7. Machine-learning fundamentals as scaffolding — activation functions, loss functions, autoregressive models, feature engineering, cross-validation
Recommended reading · 6
  • Attention Is All You Need— Vaswani et al., 2017
  • The Illustrated Transformer— Jay Alammar
  • Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks— Lewis et al., 2020
  • LoRA: Low-Rank Adaptation of Large Language Models— Hu et al., 2021
  • Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks— Reimers & Gurevych, 2019
  • What Are Foundation Models?— NVIDIA
The trap

Advice that this exam is "all applied, no theory" is wrong here. Attention and transformer mechanics run through most of this domain, more heavily than any other subject anywhere on the paper. You will not be asked to derive the maths, but you do need to explain what a mechanism does, why it exists and how it fails. Learn the architecture properly first, then layer the selection decisions on top.

Software Development

24%

of the exam

Building, serving, optimising and monitoring the software around a model — the engineering that turns a checkpoint into a service.

What you need to be able to do

  • Deploy models and evaluate their scalability, performance and reliability
  • Build LLM applications such as retrieval pipelines, chatbots and summarizers
  • Identify the data, hardware and software components needed to meet a stated user need
  • Monitor data collection, experiments and other running processes
  • Use Python NLP packages and vector databases in production code
  • Write software components and scripts to support a model-backed system

Where the questions concentrate

  1. Inference serving and memory management — vLLM and paged attention, KV-cache growth at long context, and why the serving ceiling is usually a memory ceiling
  2. Monitoring and observability of a live service: what to instrument, which signals catch drift, latency regressions and quality decay
  3. NVIDIA Triton Inference Server — what it gives you that a hand-rolled web wrapper does not
  4. TensorRT and TensorRT-LLM for optimising a model before it is served
  5. Batching strategies, including continuous batching, and the throughput-versus-latency trade-off
  6. Quantization — INT8 and lower precision, and how quantization-aware training recovers accuracy
  7. Sizing hardware and components for a stated workload
  8. Cost optimisation, troubleshooting a degraded service, and basic recovery planning
Recommended reading · 6
  • Triton Inference Server documentation— NVIDIA
  • TensorRT — Get Started— NVIDIA
  • Efficient Memory Management for LLM Serving with PagedAttention— vLLM, 2023
  • Mastering LLM Techniques: Inference Optimization— NVIDIA
  • Achieving FP32 Accuracy for INT8 Inference with Quantization-Aware Training— NVIDIA
  • NeMo Best Practices— NVIDIA
The trap

The phrase "write software components or scripts" makes this sound like a coding exam. It is not. Almost nothing here tests Python syntax; the questions concentrate on the serving and optimisation stack — Triton, TensorRT, vLLM, quantization, batching, monitoring. Prepare by learning what each tool is for and where it sits in a pipeline, not by drilling code.

Experimentation

22%

of the exam

Performing, evaluating and interpreting experiments — including model evaluation and the use of human subjects in labeling and reinforcement learning from human feedback.

What you need to be able to do

  • Evaluate a model against a held-out set and interpret what the result does and does not show
  • Compare models using statistical performance metrics such as loss functions and explained variance
  • Design and read an A/B test, including what a control arm is for and when a result is not significant
  • Understand reinforcement learning from human feedback — reward models, preference data and annotator agreement
  • Use benchmarks appropriately and know what they license you to claim
  • Evaluate a retrieval pipeline, scoring retrieval quality separately from answer quality
  • Identify factors, confounds and trends that could affect an experimental result

Where the questions concentrate

  1. Evaluation metrics, well ahead of anything else in this domain — perplexity, BLEU and ROUGE, precision, recall and F1. Which metric answers which question, and why one aggregate number hides the failure that matters
  2. Reinforcement learning from human feedback: reward models, where preference labels come from, and annotator agreement
  3. A/B testing: designing the comparison, choosing a control, and interpreting a result that is not statistically significant
  4. Benchmarks and their limits — GLUE, elementary language-task benchmarking, zero-shot evaluation
  5. Evaluating retrieval pipelines, keeping retrieval quality and answer quality as separate measurements
  6. Treating an optimisation as an experiment: change one variable, re-run the same evaluation, report the difference
  7. Detecting hallucination and attributing it to retrieval or generation
  8. Cross-validation, train/validation/test discipline, and data leakage
Recommended reading · 6
  • How to Conduct A/B Testing in Machine Learning
  • Evaluating RAG Applications
  • Hallucinations in LLMs
  • GLUE Benchmark
  • Speech and Language Processing— Jurafsky & Martin
  • Cross-Validation in Machine Learning
The trap

This domain is worth more than one exam question in five, and it is where under-prepared candidates lose the most marks — partly because the name suggests broad data work when the questions are tightly focused on evaluating models. Build a real evaluation set, learn the metrics properly, and understand RLHF and A/B testing. Charting and data-mining skills earn nothing here.

Data Analysis and Visualization

14%

of the exam

Inspecting, cleaning and transforming data, and presenting what you find — with a strong emphasis on GPU-accelerated tooling.

What you need to be able to do

  • Extract insights from large datasets using data mining and visualization techniques
  • Prepare text for model input — stemming, lemmatization, vectorization and normalization
  • Use GPU-accelerated data science tooling such as RAPIDS and cuML
  • Compare models using statistical performance metrics
  • Create charts and visualizations that convey a result accurately
  • Identify relationships, trends and factors that could affect a result

Where the questions concentrate

  1. GPU-accelerated data science with RAPIDS and cuML — where they fit relative to pandas and scikit-learn, and when the GPU actually pays off
  2. Text preprocessing for model input: stemming versus lemmatization, vectorizers, stop-word and normalization decisions, and how each affects a retrieval index
  3. Tokenization and text representation as a data-preparation concern, not just a modelling one
  4. Data exploration and quality inspection before training — missing values, class balance, duplicate detection
  5. Choosing the right statistic to compare two models, and what explained variance tells you
  6. Reading and building a visualization that represents a result honestly
  7. Spotting confounds that could explain an apparent improvement
Recommended reading · 5
  • RAPIDS— NVIDIA
  • GPU Accelerated Data Science With RAPIDS— NVIDIA
  • cuML documentation— NVIDIA
  • Stemming and Lemmatizing With sklearn Vectorizers
  • Data Exploration
The trap

This is the lightest domain, and generic pandas-and-matplotlib knowledge will carry most of the concepts — but not the tooling questions. NVIDIA is specific here: know what RAPIDS and cuML do and when you would reach for them. An hour on the GPU data-science stack is the highest-yield hour available anywhere on this exam.

Trustworthy AI

10%

of the exam

Building AI systems that are ethical, fair, private, transparent and verifiable — and knowing which control evidences each of those claims.

What you need to be able to do

  • Explain the ethical principles of trustworthy AI and the mechanism that implements each
  • Minimize bias in AI systems, and know where bias enters and how to detect it
  • Balance data privacy against the value of data, and handle consent properly
  • Use NVIDIA and other technologies to improve the trustworthiness of a system
  • Apply a recognised risk-management framework to an AI project
  • Defend a system against prompt injection, including through retrieved content

Where the questions concentrate

  1. Bias, the largest subject in this domain by a wide margin — where it enters through data, model and deployment, and why per-slice evaluation finds what aggregate accuracy hides
  2. Privacy and consent as engineering constraints: why you cannot remove one person's data from trained weights, and why that argues for retrieval over fine-tuning
  3. The NIST AI Risk Management Framework and its four functions — Govern, Map, Measure, Manage — and what each is for
  4. NeMo Guardrails: what a rail is, and why an external control layer produces an audit trail that a trained-in refusal cannot
  5. Prompt injection, including indirect injection through retrieved documents, which makes corpus trust a security property
  6. Transparency and citation — what a model-generated rationale does and does not evidence
  7. Energy and efficiency considerations, at the level of understanding the argument rather than quoting figures
Recommended reading · 4
  • AI Risk Management Framework (AI RMF 1.0)— NIST
  • NeMo Guardrails documentation— NVIDIA
  • What Is Trustworthy AI?— NVIDIA
  • Trustworthy AI for A Better World— NVIDIA
The trap

The smallest domain is also the most underestimated. It sounds like a policy essay and is tested as engineering: expect to identify the specific control, framework function or evaluation that implements a principle. Learn the NIST AI RMF functions by name and know NeMo Guardrails as a product, and you will pick up marks most candidates leave behind.

Who the exam is for, and how deep to go

The role this certification is written for, and the level of detail the questions expect.

An associate developer contributing to generative AI and LLM systems: developing datasets, selecting and training models, implementing testing and debugging, and deploying models into applications.

What the role involves

  • Writing and iterating prompts to achieve a specified result
  • Choosing between models for a given task and constraint
  • Defining, curating, labeling, and annotating datasets
  • Running experiments — A/B tests, prompt evaluations, model evaluations, proofs of concept
  • Implementing testing and debugging for model-backed software
  • Deploying models into applications with senior oversight

Recommended background

  • Python — assumed everywhere, including by the questions that name specific libraries
  • PyTorch or TensorFlow at working level
  • Solid neural network and deep learning understanding
  • Familiarity with C is listed, though it is tested only indirectly

How deep the questions go

Questions ask what a technique is for, what it costs, how to run it, and when it is the wrong choice. They do not ask you to derive a formula or implement an algorithm from scratch. Expect scenarios that hand you a goal and a constraint — latency, memory, budget, no retraining, must cite sources — and ask which approach fits. Recognition and judgement carry far more marks than recall.

Booking, cost and retaking NCA-GENL

How to register, what it costs, what happens if you fail, and what you may take into the room.

How do you book the NCA-GENL exam?

You register through NVIDIA's certification portal and schedule a slot with its proctoring partner. The exam is delivered online under remote proctoring, so there is no test centre to travel to — you need a webcam, a stable connection, a government photo ID and a quiet room you can clear of notes and second screens.

What does NCA-GENL cost?

The exam fee is $125 USD. NVIDIA periodically offers discounted or complimentary vouchers around GTC and other developer events, so it is worth checking for an active promotion before paying full price. The fee covers one attempt; a retake is charged again.

What happens if you fail, and how soon can you retake it?

A failed attempt is not published anywhere and does not appear on your record. You may retake the exam, paying the fee again, and NVIDIA applies a short waiting period between attempts. Use the gap deliberately: the score report breaks your result down by domain, which tells you exactly which of the five to rebuild before sitting it again.

When do you get your result?

You see a pass or fail outcome as soon as you submit, with a per-domain breakdown rather than a raw score. The digital badge and certificate follow by email, usually within a few business days, and the badge is verifiable by anyone you share it with.

What can you bring into the exam?

Nothing. No notes, no calculator, no second monitor, no reference material of any kind, and the proctor will ask you to show the room before you start. Nothing on the exam requires arithmetic beyond mental estimation, so a calculator would not help you anyway.

Is there a lab or practical component?

No. NCA-GENL is entirely multiple choice — 50 to 60 questions in 60 minutes, with roughly a quarter of them asking you to select exactly two answers. You will not be asked to write or run code, which is why preparation should target recognition and judgement rather than implementation practice.

NCA-GENL or another NVIDIA certification?

Four NVIDIA generative-AI credentials have similar names and very different scopes. How this one differs from its neighbours, and who should sit each.

NCA-GENL vs NCP-GENL

NVIDIA Certified Professional: Generative AI LLMs

How it differs

The professional-level version of the same subject area: 120 minutes against 60, ten domains against five, and a published 70% cut score where the associate exam has none. It expects you to architect and troubleshoot LLM systems independently rather than contribute to one with senior oversight.

Choose it when

You already build and operate LLM systems day to day and want the credential that reflects that. Most people sit NCA-GENL first, since it covers the same vocabulary at a depth you can reach in weeks rather than months.

NCA-GENL vs NCA-GENM

NVIDIA Certified Associate: Generative AI Multimodal

How it differs

The same associate level and the same 60 minutes, but spread across seven domains covering images, audio and video alongside text. It trades the LLM depth of NCA-GENL — transformers, retrieval, serving — for breadth across modalities.

Choose it when

Your work involves vision or speech models as much as language ones. If you work mainly with text and retrieval, NCA-GENL is the closer match and the more widely recognised starting point.

NCA-GENL vs NCP-AAI

NVIDIA Certified Professional: Agentic AI

How it differs

A professional-level exam about agents specifically — tool use, planning loops, multi-step orchestration — over 120 minutes and ten domains, with a 70% cut score. It assumes the LLM fundamentals NCA-GENL tests and builds on them.

Choose it when

You are building agentic systems and already have the foundations. It is a poor first certification, because it takes the transformer, retrieval and evaluation knowledge from NCA-GENL as a given.

NCA-GENL glossary

The vocabulary the exam assumes you already have, defined the way the questions use it.

Self-attention30%
The mechanism that lets every token in a sequence look at every other token and weight how much each one matters to it. It replaced recurrence because those comparisons happen in parallel rather than step by step, which is what made training on very large corpora practical. This is the single most heavily questioned subject on NCA-GENL.
RAGRetrieval-Augmented Generation30%
Retrieving relevant documents at query time and putting them in the prompt, so the model answers from supplied text rather than from its weights. It is the right answer whenever a question mentions facts that change, citations, or the need to delete one user's data — none of which fine-tuning can deliver.
Embedding30%
A vector of numbers representing a piece of text, positioned so that semantically similar text lands nearby. Retrieval works by embedding the query and finding the nearest stored vectors, which is why the choice of embedding model determines what your retriever can and cannot find.
LoRALow-Rank Adaptation30%
A parameter-efficient fine-tuning method that freezes the original weights and trains small low-rank matrices alongside them. It reaches most of the quality of full fine-tuning at a fraction of the memory and storage cost, and NCA-GENL treats it as core associate-level knowledge rather than an advanced topic.
KV cacheKey-Value cache24%
The stored attention keys and values for tokens already processed, kept so the model does not recompute them for every new token. It grows with sequence length and concurrent requests, which is why the ceiling on a serving deployment is usually memory rather than compute.
Paged attention24%
A memory-management technique, introduced by vLLM, that allocates the KV cache in fixed-size blocks instead of one contiguous region. It removes the fragmentation that otherwise wastes GPU memory, allowing many more concurrent requests on the same hardware.
Quantization24%
Storing weights and activations at lower numeric precision — INT8 or below instead of 16-bit — to cut memory and raise throughput, at some cost to accuracy. Quantization-aware training recovers most of that accuracy by simulating the reduced precision during training rather than applying it afterwards.
Continuous batching24%
Admitting new requests into a running batch as earlier ones finish, instead of waiting for the whole batch to complete. It raises throughput substantially while adding some latency to any individual request — the trade-off the exam asks you to reason about.
Perplexity22%
A measure of how surprised a language model is by text, derived from its loss. Lower is better, and it is useful for comparing two models on the same corpus — but it says nothing about whether output is accurate, useful or safe, which is the limitation questions probe.
RLHFReinforcement Learning from Human Feedback22%
Training a reward model on human preferences between pairs of outputs, then using it to tune the language model towards preferred responses. On NCA-GENL it sits inside Experimentation, and the questions concern reward models, where preference labels come from, and how much annotators agree.
F1 score22%
The harmonic mean of precision and recall, giving a single number where both matter. It is the metric to reach for on an imbalanced dataset, because raw accuracy can look excellent while the model misses almost every case in the minority class.
RAPIDS14%
NVIDIA's suite of GPU-accelerated data science libraries, including cuDF for dataframes and cuML for machine learning, with APIs that deliberately mirror pandas and scikit-learn. It pays off on large datasets where the work is parallel; on small ones the transfer overhead outweighs the gain.
Lemmatization14%
Reducing a word to its dictionary form using vocabulary and grammar, so "was" becomes "be". Stemming instead chops affixes mechanically and can produce non-words; lemmatization is slower but preserves meaning, which matters when the output feeds a retrieval index.
NIST AI RMFNIST AI Risk Management Framework10%
A voluntary framework organised around four functions — Govern, Map, Measure and Manage — for identifying and handling AI risk across a system's life cycle. Knowing the four function names and what each covers is directly examinable in Trustworthy AI.
Guardrails10%
An external control layer that constrains what a model-backed system will discuss or do, implemented as programmable rails around the model rather than behaviour trained into it. The exam's angle is auditability: an external rail leaves a log you can inspect, where a trained-in refusal leaves nothing.
Indirect prompt injection10%
An attack where instructions hidden in retrieved content — a web page, a document in your corpus — are followed by the model as though the user had issued them. It makes the trustworthiness of your corpus a security property, not merely a quality one.

Essential reading

The papers and documentation worth your time before the exam, most valuable first. The top four cover the intellectual backbone of the whole syllabus.

  1. Retrieval-Augmented Generation for Knowledge-Intensive NLP TasksLewis et al., 2020 — the RAG paper, and the most valuable single read for this exam
  2. Attention Is All You NeedVaswani et al., 2017 — the transformer
  3. The Illustrated TransformerJay Alammar — read alongside the paper above
  4. LoRA: Low-Rank Adaptation of Large Language ModelsHu et al., 2021
  5. BERT: Pre-training of Deep Bidirectional TransformersDevlin et al., 2018
  6. Sentence-BERT: Sentence Embeddings using Siamese BERT-NetworksReimers & Gurevych, 2019
  7. Mastering LLM Techniques: TrainingNVIDIA Developer
  8. Efficient Memory Management for LLM Serving with PagedAttentionvLLM, 2023
  9. Triton Inference Server documentationNVIDIA
  10. NeMo Guardrails documentationNVIDIA
  11. AI Risk Management Framework (AI RMF 1.0)NIST
  12. SentencePiece: A simple and language independent subword tokenizerKudo & Richardson, 2018

Common questions

The questions people ask most often before booking this exam.

What is the passing score for NCA-GENL?

NVIDIA does not publish one. Rather than aiming at a number, judge readiness by consistency: you are ready when you score well across all five domains with none lagging behind, especially Experimentation.

How many questions are on the exam?

Between 50 and 60 multiple-choice questions, with 60 minutes to complete them. Practise at one minute per question so the longest version of the paper still feels comfortable.

How hard is NCA-GENL?

It is an associate-level exam, and the difficulty is breadth rather than depth. Most questions sit at a moderate level: they ask you to choose between reasonable options given a constraint, not to recall obscure detail or derive anything. The challenge is that the material spans architecture, retrieval, serving, evaluation and ethics.

How long does it take to prepare?

With working Python and some machine-learning background, 30 to 45 hours of focused study is realistic. Budget more if you have never built a retrieval pipeline, less if you work with LLMs daily. Experimentation usually takes longer than people expect.

Which domain should I study first?

Core Machine Learning and AI Knowledge. It is the largest single domain and everything else builds on it — transformers, embeddings, retrieval and prompting all reappear in the other four. Follow it with Software Development and Experimentation.

Are there multi-answer questions?

Yes, and roughly a quarter of the exam is made up of them. They are phrased "Select TWO" and require exactly two answers. There is no partial credit, so one correct selection out of two scores the same as leaving it blank.

Do I need to know NVIDIA-specific products?

Yes. Triton, TensorRT, NeMo, NeMo Guardrails, RAPIDS and cuML all appear. You do not need hands-on experience with each, but you do need to know what every one of them is for and where it belongs in a pipeline.

Does the exam cover RLHF?

Yes. Reinforcement learning from human feedback sits inside Experimentation alongside model evaluation, and you should understand reward models, preference data and annotator agreement.

How much does it cost and how is it delivered?

The NCA-GENL exam costs $125 USD and is taken online under remote proctoring, so you can sit it from home with a webcam and a quiet room. You get 60 minutes for 50 to 60 multiple-choice questions. There is no lab or practical component.

How long is the certification valid?

Two years. Recertification means retaking the exam. As an associate credential it signals working familiarity with the NVIDIA generative-AI stack, which is most useful early in a career or when moving into an LLM-focused role.

You know the shape of the exam. Now sequence the work.

The study guide turns everything above into six ordered phases, each with a practice exercise and self-checks to tell you when to move on.

Open the study guidePractise by domain