How many Troubleshooting Scenario Questions questions are on this page?

This page has 5 Troubleshooting Scenario Questions scenario questions for the NCP-GENL exam, each with detailed explanations and wrong-answer analysis.

How should I approach NCP-GENL scenario questions?

Read the full scenario before looking at the answer options. Identify the constraint or requirement in the scenario, then eliminate options that are generally true but wrong for this specific case. Scenario questions reward careful reading over pattern matching.

← Back to NVIDIA Certified Professional: Generative AI LLMs questions

Scenario-based practice

Troubleshooting Scenario Questions

Practise NVIDIA Certified Professional: Generative AI LLMs practice questions — original exam-style scenarios covering every exam domain, with detailed explanations, wrong-answer analysis, and common exam traps.

Start full practice test Read exam guide

scenario questions

NCP-GENL

exam code

NVIDIA

vendor

Scenario guide

How to approach troubleshooting scenario questions

These questions describe a network symptom and ask you to identify the root cause or the correct fix. They appear across all certification exams and reward systematic thinking over memorisation. The best candidates follow a consistent troubleshooting framework even under time pressure.

Quick answer

Troubleshooting Scenario Questions questions test whether you can apply the concept in context, not just recognise a definition.

How the topic appears in realistic exam-style scenarios.

Which detail in the question changes the correct answer.

How to eliminate plausible but wrong options.

How to connect the question back to the wider exam objective.

Practice scenarios

Question 1hardmulti select

Full question →

An engineer is analyzing why a decoder-only LLM with 32,000-token context length fails to answer questions that require information from the beginning of a long document when the answer is near the end. The model was trained with standard causal attention. Which two architectural or training factors are most likely contributing to this failure? (Choose two.)

A
The feed-forward network in each layer compresses the hidden state, discarding information from early tokens.
Why it fails: The feed-forward network operates on each position independently and does not selectively discard early-token information. While it transforms representations, the residual stream preserves information across layers. The bottleneck for long-context retrieval is attention and positional encoding, not feed-forward compression, which is not a recognized cause of this failure mode.
B
The vocabulary size is too small to represent the document's domain-specific terms, causing tokenization errors.
Why it fails: Vocabulary size affects tokenization granularity but does not explain why information at the beginning of a long context is ignored. Even with a large vocabulary, the model could still fail to attend across 32,000 tokens if it was not trained on such lengths or if positional encoding does not generalize. This factor is unrelated to the described long-context retrieval failure.
C
The positional encoding scheme may not generalize well beyond the sequence lengths seen during pretraining.
Many positional encoding schemes, especially learned absolute embeddings or RoPE without scaling, degrade when sequences exceed the lengths seen during training. The model cannot reliably distinguish or weight positions far beyond its training range, so attention to early tokens becomes imprecise. This directly contributes to the failure to retrieve information from the beginning of a long document.
D
Causal attention masks prevent each token from attending to future tokens, which limits bidirectional reasoning over the document.
Why it fails: Causal masking is inherent to decoder-only models and is not a defect; it ensures autoregressive generation. The question is about attending to earlier tokens, which causal attention does allow. The failure to use early information stems from training distribution and positional encoding behavior, not from the causal mask itself, which is functioning as intended.
E
The model was pretrained primarily on sequences much shorter than 32,000 tokens, so it did not learn to attend across the full context.
If pretraining used sequences far shorter than the target context length, the attention patterns never learned to connect distant tokens. Extending context at inference without training on long sequences leads to poor utilization of early tokens. This is a well-documented cause of the lost-in-the-middle effect, where information at the extremes of a long context is underused.

Full breakdown with real-world context →

Question 2hardmultiple choice

Full question →

An engineer is optimizing prompts for an NVIDIA NIM-hosted model used in a multi-turn technical troubleshooting chat. The model forgets earlier constraints, such as the customer's environment and the product version, as the conversation grows. Which prompt engineering technique best preserves these constraints across turns?

A
Repeat the full conversation history verbatim in every turn and increase max_tokens.
Why it fails: Repeating the entire history can preserve details, but it grows token usage quickly and may push important constraints out of the effective context or dilute attention. Increasing max_tokens does not improve memory of earlier turns. This approach is inefficient and can degrade performance as irrelevant dialogue accumulates, rather than reliably preserving the key constraints.
B
Maintain a compact running summary of key constraints and inject it into the system prompt each turn.
A running summary keeps essential facts such as environment and product version in a stable, high-priority position, so they survive across turns without unbounded token growth. Injecting it into the system prompt gives those constraints consistent influence over every response. This directly addresses forgetting while controlling context length in a multi-turn chat.
C
Use a single-turn prompt for each message and rely on the model's pretrained knowledge of the product.
Why it fails: Treating each message as a single turn discards the conversation state entirely, so the model cannot recall the customer's environment or version. Pretrained knowledge is generic and may not match the specific deployment. This approach guarantees that earlier constraints are lost and increases the chance of irrelevant or incorrect troubleshooting steps.
D
Lower the temperature to 0 and remove the system prompt to avoid conflicting instructions.
Why it fails: Lowering temperature makes responses more deterministic but does nothing to preserve earlier constraints. Removing the system prompt eliminates a prime location for persistent instructions, making the model more likely to forget them. This combination reduces both consistency and the ability to carry forward important context across turns.

Full breakdown with real-world context →

Question 3hardmultiple choice

Full question →

An LLM inference service running on NVIDIA Triton Inference Server is configured with model ensembles. During production monitoring, the operations team notices that the end-to-end latency reported by the client is significantly higher than the sum of individual model latencies reported by Triton's metrics. Which Triton feature should be investigated to identify the source of the additional latency?

A
Model ensemble scheduler overhead and inter-model data transfer
Triton's ensemble scheduler manages the execution of multiple models and handles data transfer between them. This can introduce overhead not captured in individual model latency metrics. Investigating ensemble scheduling and data transfer times can reveal bottlenecks. The discrepancy between client-side and server-side latency suggests overhead in the ensemble pipeline, such as serialization or scheduling delays.
B
GPU memory utilization causing queuing of inference requests
Why it fails: GPU memory utilization can cause queuing, but that queuing time would be reflected in Triton's server-side latency metrics as increased model execution time. The scenario specifies that the sum of individual model latencies is lower than client-observed latency, indicating additional time spent outside individual model executions, such as ensemble scheduling overhead.
C
Network latency between the client and the Triton server
Why it fails: Network latency would affect the client-side measurement but would not cause a discrepancy between client-side and server-side latencies as reported by Triton. Triton's server-side metrics measure time from request receipt to response, excluding network time. The question focuses on a gap between client-observed and server-reported latencies, pointing to internal processing overhead rather than network.
D
Dynamic batching configuration causing delays in request aggregation
Why it fails: Dynamic batching delays are typically included in the model's latency metrics because they occur before inference execution. While batching can add latency, Triton reports it as part of the model's execution time. The scenario describes a gap between client-side and server-side latencies, which is more indicative of ensemble overhead rather than batching delays within individual models.

Full breakdown with real-world context →

Question 4hardmultiple choice

Full question →

A production LLM service on NVIDIA Triton Inference Server is deployed across multiple GPUs. The team notices that one GPU consistently shows higher latency for inference requests compared to others, despite similar utilization. Which NVIDIA tool should be used to investigate per-GPU performance discrepancies and identify bottlenecks?

A
NVIDIA Nsight Systems
Nsight Systems is a system-wide profiling tool that can capture GPU activities, including kernel execution times and memory transfers, across multiple GPUs. It can highlight per-GPU performance differences by showing timelines and bottlenecks. In this scenario, it can identify why one GPU is slower, such as inefficient kernel usage or thermal throttling, enabling targeted optimization.
B
NVIDIA Triton Inference Server metrics
Why it fails: Triton metrics report inference counts, latencies, and queue times per model, but they do not break down performance by GPU. They can show that latency is higher for a model, but not which GPU is responsible or why. To attribute latency to a specific GPU and diagnose bottlenecks, a lower-level profiling tool is needed.
C
NVIDIA Data Center GPU Manager (DCGM)
Why it fails: DCGM provides aggregate and per-GPU metrics like utilization, memory usage, and temperature, but it does not offer detailed kernel-level profiling. While it can indicate that one GPU is slower, it cannot pinpoint the exact cause such as specific kernel inefficiencies. For deep performance analysis, a profiler like Nsight Systems is required.
D
NVIDIA System Management Interface (nvidia-smi)
Why it fails: nvidia-smi provides basic per-GPU metrics like utilization and memory, but it lacks the granularity to diagnose performance discrepancies. It can show that one GPU has higher utilization, but not the underlying reasons such as kernel execution times. It is not a profiling tool and cannot identify bottlenecks within inference execution.

Full breakdown with real-world context →

Question 5hardmultiple choice

Full question →

Refer to the exhibit. A team is preparing log data for a RAG-based troubleshooting assistant. Given the configuration, what is the most significant risk during the retrieval phase?

Exhibit

{
  "data_source": "logs_v1",
  "privacy_filter": "regex_mask_all",
  "embedding_model": "nv-embed-v1",
  "chunk_size": 4096,
  "overlap": 0
}

A
The use of 'nv-embed-v1' will cause OOM errors during the indexing phase.
Why it fails: NVIDIA embedding models are optimized for performance and memory efficiency. Specifying a model name in a configuration file does not inherently lead to out-of-memory errors. Resource allocation is handled by the underlying infrastructure and container configuration, not the choice of the embedding model itself during the indexing stage.
B
The chunk size of 4096 tokens is too small for modern log analysis.
Why it fails: 4096 tokens is a significant chunk size, generally adequate for most log-based analysis tasks. The issue is not the size itself, but the lack of contextual continuity between these chunks. Log data requires contextual awareness of surrounding events, which is sacrificed by the lack of overlap, not by the size.
C
Setting the overlap to 0 will break contextual continuity between consecutive log entries.
Logs are inherently sequential. A zero-overlap configuration ensures that each chunk is treated as an isolated entity, potentially splitting related log events. This prevents the LLM from seeing the full narrative of a system failure, significantly reducing the diagnostic utility of the retrieval-augmented generation output for complex errors.
D
The 'regex_mask_all' policy will cause the embedding model to fail during vectorization.
Why it fails: Masking sensitive data via regex is a standard preprocessing step that is independent of the vectorization process. The embedding model generates high-dimensional representations of the sanitized text. While masking might remove some data, it does not interrupt the pipeline execution or cause the vectorization model to fail.

Full breakdown with real-world context →

These NCP-GENL practice questions are part of Courseiva's free NVIDIA certification practice question bank. Courseiva provides original exam-style NCP-GENL questions with detailed explanations, topic-based practice, mock exams, readiness tracking, and study analytics.

Troubleshooting Scenario Questions

How to approach troubleshooting scenario questions

Quick answer

Related NCP-GENL topic practice pages

Evaluation practice questions

GPU Acceleration and Optimization practice questions

LLM Architecture practice questions

Data Preparation practice questions

Production Monitoring and Reliability practice questions

Fine-Tuning practice questions

Safety, Ethics, and Compliance practice questions

Prompt Engineering practice questions

Model Optimization practice questions

Model Deployment practice questions

NCP-GENL fundamentals practice questions

NCP-GENL scenario practice questions

Practice scenarios

Refer to the exhibit. A team is preparing log data for a RAG-based troubleshooting assistant. Given the configuration, what is the most significant risk during the retrieval phase?

Exhibit