Domain 1: LLM Architecture
- A decoder block is attention followed by a position-wise feed-forward network. Attention is the only place positions exchange information; the feed-forward sublayer holds most of the parameters.
- The residual stream is a running representation each block reads from and writes back into. Pre-norm leaves that stream unnormalised, which is why deep stacks train stably.
- Grouped-query and multi-query attention collapse the key and value projections so several query heads share them. The saving is cache footprint and cache traffic, and the cost is some modelling capacity.
- The key-value cache is two tensors per layer sized by heads, positions generated and head dimension. Depth, heads, length and concurrency all multiply it.
- Rotary encoding rotates queries and keys by a position-dependent angle, so attention depends on the distance between positions. That relative property is what makes context extension tractable.
- A mixture-of-experts layer routes each token to a few experts, so total parameters and parameters active per token diverge. Quoting only the total overstates the arithmetic per token.
- Subword tokenization gives a bounded vocabulary that can still spell anything. Poor coverage of a language costs more tokens for the same content, and every downstream cost is per token.
- Know where the memory goes: the weights are a fixed cost shared by every session, and the cache is the variable cost that decides concurrency.
Domain 2: Prompt Engineering
- The system message is the one part of a conversation that does not scroll away. Standing instructions belong there, not in the first user turn.
- Asking for a structure raises the proportion of conforming responses without guaranteeing any of them. Constrained decoding is what makes malformed output unreachable, at the cost of possibly distorting the content.
- Few-shot examples are sensitive to ordering, and later examples often weigh more. Selecting them per request makes two identical requests diverge and makes a regression unattributable.
- Step-by-step reasoning works because the intermediate tokens become context later tokens condition on. You pay for every one of them as output.
- A stated chain of reasoning can be a post-hoc rationalisation, and a stated confidence is generated in the same way the answer was. Neither is evidence.
- In retrieval, chunk size trades dilution against context spend, and passages belong near the question because attention over a long input is uneven.
- Measure retrieval and generation separately: whether the answer-bearing passage was retrieved at all, and whether the answer is supported by what was retrieved. No prompt change fixes missing evidence.
- Prefix caching only works when everything stable comes first. A timestamp at the top of a prompt destroys the hit rate silently.
Domain 3: Data Preparation
- Record the source of each portion and the terms it was obtained under. Accessibility is not permission, and the question is asked long after collection.
- Deduplicate before splitting, not after. Deduplicating each portion separately leaves exactly the cross-portion duplicates that inflate an evaluation.
- Near-duplicates need a similarity method and a threshold; a hash catches only identical bytes. Read a sample of what the threshold calls a duplicate before trusting it.
- Benchmark contamination inflates a reported score. Items spread across the web in forums and repositories, and a paraphrase evades any exact-string filter.
- Quality filters have false positives. Symbol-heavy heuristics remove source code and mathematics, and a model-based scorer imprints its own preferences on the whole corpus.
- Repetition drives memorisation, which is what makes personal data in a corpus recoverable from the weights afterwards. De-duplication and redaction act before any harm is possible.
- Instruction data is far smaller, far more curated and far more determining of behaviour than pretraining data. Coverage of what users actually ask beats volume.
- Mask the loss over the request and apply it to every assistant turn. Without the mask, part of the budget teaches the model to write user messages.
Domain 4: Model Optimization
- Post-training quantisation needs only a calibration sample and no training rig; quantisation-aware training reaches lower bit widths because the weights adapt to the rounding.
- Calibration observes activation ranges from representative inputs. A sample from the wrong distribution fits the range to inputs the model rarely sees and clips the ones it does.
- Weight-only quantisation helps single-stream generation, which is bandwidth-bound. It does nothing for large-batch prefill, which is already arithmetic-bound.
- Activation outliers are rare, extreme and load-bearing. Keeping those channels wide, or rescaling to move the difficulty onto the weights, is what makes activation quantisation viable.
- Measure quantisation on the task, not on weight error. Long multi-step reasoning degrades first, so a suite of short tasks passes a model that has lost its long-chain capability.
- Unstructured pruning gives a sparse model and no speedup unless the hardware skips the zeros. Structured pruning gives genuinely smaller tensors that any hardware multiplies faster.
- Paged cache allocation removes the waste of reserving for a maximum length and makes prefix sharing between sessions possible.
- Speculative decoding is free of quality cost when implemented correctly, and it only helps where there is idle arithmetic capacity to reclaim - which excludes large-batch serving.
Domain 5: Fine-Tuning
- Full fine-tuning needs gradients and optimiser state alongside the weights, which together exceed the weights several times over.
- A low-rank adapter is two thin matrices whose product is added to a frozen weight. The rank sets both what it can express and what it costs.
- Adapters take a higher learning rate than a full fine-tune, because the trainable parameters start from a neutral state.
- Freezing the base means the original behaviour is recoverable, which is a guarantee no full fine-tune offers. Full tuning needs general data mixed in and a gentle schedule to limit forgetting.
- Evaluate a fine-tune on the target behaviour AND on a general capability suite. A narrow evaluation measures the gain and is blind to what was lost.
- Compare against the base model given the best prompt anybody could write. Beating an unengineered baseline proves nothing about whether the tuning was needed.
- Preference data expresses judgements between acceptable answers that demonstrations cannot. Reward hacking is what happens when you optimise hard against a proxy.
- The run is the cheap part. The artefact you now version, serve and re-create on every base upgrade is the expensive part.
Domain 6: Evaluation
- Perplexity is comparable only across models sharing a tokenizer and a test corpus, and a falling figure does not mean a more useful model.
- Reference-based overlap metrics penalise a correct answer phrased differently and reward a wrong answer that reuses the reference's vocabulary.
- Judge models exhibit a documented preference for longer answers, so a change that only lengthens responses wins a judged comparison.
- A judge favours output from its own model family. Use a judge unrelated to both candidates.
- Pairwise judging is more consistent than absolute scoring and produces no standalone figure, so tracking across releases needs a fixed reference system.
- Position bias is real: run each pair in both orders and combine the verdicts.
- A suite of a few dozen items cannot resolve a difference of a few points. Report an interval, and treat overlapping intervals as an open question rather than a result.
- A suite every release passes has stopped discriminating. Feed it production failures and retire the cases everything has passed for many rounds.
Domain 7: GPU Acceleration and Optimization
- Every kernel is bound by memory bandwidth or by arithmetic, and arithmetic intensity - work per byte moved - decides which.
- Single-token decoding reads every weight to do one multiply each, which is the lowest intensity the model ever runs at. Prefill reuses each weight across every position and saturates the arithmetic units.
- Fused kernels perform the same arithmetic with less memory traffic. Fused attention never materialises the full score matrix, which makes its memory linear rather than quadratic in the sequence.
- Tensor cores accelerate fixed shapes at low precision. Dimensions that do not divide into those blocks are padded, wasting arithmetic on values that contribute nothing.
- Data parallelism replicates the model and splits the batch; tensor parallelism splits the matrices within a layer; pipeline parallelism splits by depth; sequence and expert parallelism split the positions and the experts.
- Match each split to the link it runs over: tensor parallelism inside a machine on the fast local interconnect, pipeline parallelism across machines.
- A collective is a barrier as well as an exchange, so one slow device sets the pace for the whole group. Overlap the gradient exchange with the backward pass, in buckets.
- Judge scaling by throughput per device against one device alone. Total throughput rises with the device count whatever the efficiency.
Domain 8: Model Deployment
- A serving runtime adds scheduling, batching and cache management. A training framework computes the same forward pass and wastes most of the device under load.
- Container images have to match the driver the host provides; the accelerator boundary is not isolated. Weights usually live outside the image, which needs a recorded binding and a startup budget.
- Cold start is dominated by loading the weights, not by process startup, which is why autoscaling has to anticipate demand rather than react to it.
- A model registry records what an artefact is made of and why it was allowed out. Promote the artefact rather than rebuilding it for production.
- Shadow deployment sends copies of real traffic and discards the output; a canary sends real output to a small share of users. Neither is useful without a measurement watched during the window.
- Roll back by pointing at the previous artefact, which has to still exist and still be loadable. Retraining takes hours where a rollback needs minutes.
- An endpoint is a contract, not just an address. Swapping the model behind it changes behaviour with no signal, so offer pinned versions alongside a floating one.
- Bound both the request and the caller: a token limit on any single response, and a rate limit scoped per caller rather than across the service.
Domain 9: Production Monitoring and Reliability
- Measure time to first token and the inter-token interval separately. They are produced by different phases and a single figure hides which is at fault.
- Requests per second is not a unit of work when one request generates five tokens and another five thousand. Queue depth is the saturation signal that matters.
- Count refusals and faults separately. Merging them makes a capacity problem look like a broken model.
- An error budget is a budget for risk, spent on releases and unplanned failures alike. Exhausting it early is the signal to prioritise reliability over new work.
- Alert on symptoms users experience rather than on causes, and only on things somebody can act on. A page that needs no action trains everybody to ignore pages.
- Quality degrades in a deployment whose model never changed, because the traffic moves. Watch the input distribution, then judge a sample of the new traffic.
- Implicit signals - retries, rephrases, abandonment - are plentiful and ambiguous, so compare rates between variants rather than reading single interactions.
- Shed load by caller and protect in-flight work; make clients back off with jitter; use a circuit breaker that reopens on a successful trial rather than on a timer.
Domain 10: Safety, Ethics, and Compliance
- Safety training lowers the rate of harmful output without bounding it, which is why a check sits between the model and the reader.
- An output filter trades over-blocking against under-blocking. Over-blocking is a real harm: users route around a tool that refuses ordinary work, leaving less protection than a calibrated filter.
- A per-request filter cannot see a pattern spread across several requests. Assessing behaviour across a session or an account is what closes that gap.
- Assume any single control will be bypassed. Layers that fail independently, and a bound on what a bypass can cause, are what survive a motivated attacker.
- A human review shown the model's proposal first drifts towards agreement. A disagreement rate near zero means the control has become a formality.
- Deleting personal data from a corpus does not remove it from weights already trained on it. Keeping it out before the run is the only step that prevents the encoding.
- Accessibility is not permission, and a provider's terms commonly restrict using its output to train a competing model. Settle both before building a pipeline.
- Accountability rests with whoever chose to deploy the system in that context. The provider's undertakings cover the component they supplied, not your use of it.
NVIDIA-Certified Professional exam tips
- Optimization dominates this exam. Model Optimization at 17 percent and GPU Acceleration at 14 come to nearly a third of the paper between them, and Fine-Tuning and Prompt Engineering add 26 more. If your study time is limited, that is where it goes.
- LLM Architecture is only 6 percent. Know the block structure, the cache shape and the attention variants well enough to reason about memory, and resist spending a week on positional encoding mathematics that will earn you two or three questions.
- A great many questions come down to one judgement: which resource is binding? Memory bandwidth or arithmetic, cache capacity or compute, the link or the device. Identify the constraint and most of the options eliminate themselves.
- Expect diagnostic questions where a symptom is described and you have to name the cause. Read for what has actually been observed rather than what might also be true - a rising time to first token with a flat inter-token interval is a different fault from both figures rising together.
- Where two options differ only in direction - faster or slower, more or fewer, before or after - the direction is the thing being tested. Work out which way the effect runs before you look at the wording.
- This is a professional exam with an experience prerequisite, so the questions assume you have operated something. Answers that sound tidy but ignore an operational cost - a rollback with no retained artefact, a scaling policy that reacts after the spike - are usually the distractors.
- Multi-select questions state how many answers to choose. Choose exactly that many, and do not assume partial credit.
- 120 minutes for up to 70 questions is a little under two minutes each, which is comfortable. Spend the surplus on the scenario items rather than second-guessing definitions.
Study guide FAQ
What is the NCP-GENL exam format?
60 to 70 questions in 120 minutes, delivered online and remotely proctored, at around $200. NVIDIA does not publish a numeric passing score, so the result is reported as pass or fail. The certification is valid for two years.
How does NCP-GENL differ from NCA-GENL?
NCA-GENL is the associate tier: five domains, 50 to 60 questions in 60 minutes, no stated experience prerequisite. NCP-GENL is the professional tier: ten domains, 60 to 70 questions in 120 minutes, and NVIDIA recommends two to three years of practical work with large language models. The professional exam adds whole domains the associate does not have, including GPU Acceleration and Optimization, Model Deployment, and Production Monitoring and Reliability.
Do I need the associate certification first?
NVIDIA states a recommended background of two to three years of practical experience rather than a formal certification prerequisite. The associate exam is a reasonable stepping stone if you are new to the material, but it is not required.
How much of the exam is hands-on or lab-based?
This is a multiple-choice exam rather than a lab. The questions assume practical experience - many describe a symptom or a constraint and ask what follows - but you are not asked to configure anything or write code during the exam.
Do I need to know specific NVIDIA products?
The published content breakdown is written in general terms - optimization, parallelism, deployment, monitoring - rather than around named products. Familiarity with the NVIDIA stack helps with context, and the underlying practice is what the questions test.
How should I use this question bank?
Work through it by domain, reading the explanation on every question including the ones you answered correctly, because the explanations state why each wrong option is wrong. Then take full weighted mocks, which draw questions in the same 6/13/9/17/13/7/14/9/7/5 proportion as the real exam - which means roughly a third of any mock will be optimization, exactly as on the day.