NVIDIA interviews vary by team, so the questions you get depend on the role: a CUDA library team asks very different things from a web or infrastructure team. Candidate reports describe a common shape: coding problems in the usual data-structures-and-algorithms style, then a domain round (C++, operating systems, GPU/CUDA or machine learning, depending on the team), plus behavioral questions. This page lists representative questions in each area, with tested answers for the coding ones. These are the kinds of questions candidates report, not a leaked list, and NVIDIA publishes no official question set.
What the process looks like
NVIDIA does not publish its interview format. Third-party prep guides and candidate reports (as of October 2026) mostly describe a recruiter call, a technical screen with a live coding problem and a resume discussion, a conversation with the hiring manager, and a final round of several interviews of 30 to 60 minutes each. The hiring team decides what the final rounds cover, and the number of rounds and the timeline differ between teams. Ask your recruiter what your loop will include, and read recent reports for your specific group rather than trusting a generic list. The official place to find roles is jobs.nvidia.com.
Coding questions
Expect standard medium-level problems on linked lists, stacks and queues, heaps, hash maps, strings and trees, and be ready for follow-ups such as “what if the input does not fit in memory?” or “make it thread-safe”. For C++ and CUDA roles, expect to code in C++. The examples below are in Python for readability; all were run on the sample inputs shown.
Reverse a linked list
Walk the list once, pointing each node back at the previous one. O(n) time, O(1) space.
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def reverse_list(head):
prev = None
while head:
head.next, prev, head = prev, head, head.next
return prev
# 1 -> 2 -> 3 becomes 3 -> 2 -> 1; reverse_list(None) returns None
The tuple assignment evaluates the right side first, so head.next is saved before it is overwritten. If you prefer a temporary variable, that is just as good in an interview. Practice it with the Reverse Linked List lesson.
Queue using two stacks
Push onto an inbox stack. When you need to pop or peek and the outbox is empty, move everything from the inbox to the outbox, which reverses the order. Each element moves at most twice, so each operation is O(1) amortized.
class MyQueue:
def __init__(self):
self.inbox = []
self.outbox = []
def push(self, x):
self.inbox.append(x)
def _shift(self):
if not self.outbox:
while self.inbox:
self.outbox.append(self.inbox.pop())
def pop(self):
self._shift()
return self.outbox.pop()
def peek(self):
self._shift()
return self.outbox[-1]
def empty(self):
return not self.inbox and not self.outbox
q = MyQueue()
q.push(1); q.push(2)
print(q.peek(), q.pop(), q.empty()) # 1 1 False
q.push(3)
print(q.pop(), q.pop(), q.empty()) # 2 3 True
A common mistake is to shift on every operation, or to shift while the outbox still has items, which breaks the order.
Kth largest element
Sorting works in O(n log n). Better: keep a min-heap of the k largest values seen so far. The heap’s top is then the kth largest. O(n log k) time, O(k) space. Mention quickselect (average O(n), worst case O(n^2)) as the alternative.
import heapq
def find_kth_largest(nums, k):
heap = []
for x in nums:
if len(heap) < k:
heapq.heappush(heap, x)
elif x > heap[0]:
heapq.heapreplace(heap, x)
return heap[0]
print(find_kth_largest([3, 2, 1, 5, 6, 4], 2)) # 5
print(find_kth_largest([3, 2, 3, 1, 2, 4, 5, 5, 6], 4)) # 4
Duplicates count separately here: in the second example the sorted order is 6, 5, 5, 4, so the 4th largest is 4. Ask whether the problem means that or “kth distinct”. The Smallest K II lesson uses the same heap idea.
LRU cache
Caches are a natural fit for a hardware company, and “design an LRU cache” is a common question in general. Python’s OrderedDict gives O(1) get and put; in C++ the equivalent is a hash map plus a doubly linked list, which interviewers may ask you to write by hand.
from collections import OrderedDict
class LRUCache:
def __init__(self, capacity):
self.cap = capacity
self.data = OrderedDict()
def get(self, key):
if key not in self.data:
return -1
self.data.move_to_end(key)
return self.data[key]
def put(self, key, value):
if key in self.data:
self.data.move_to_end(key)
self.data[key] = value
if len(self.data) > self.cap:
self.data.popitem(last=False)
c = LRUCache(2)
c.put(1, 1); c.put(2, 2)
print(c.get(1)) # 1
c.put(3, 3) # evicts key 2
print(c.get(2)) # -1
c.put(4, 4) # evicts key 1
print(c.get(1), c.get(3), c.get(4)) # -1 3 4
For the policies behind it, see FIFO vs LRU vs LFU.
GPU and CUDA questions
These come up for roles close to the hardware or the CUDA stack. Know the following well enough to explain in your own words, ideally with a small example on a whiteboard.
- Execution hierarchy. A kernel launches a grid of thread blocks; a block’s threads run on one streaming multiprocessor and can share memory and synchronize with
__syncthreads(). Threads execute in groups of 32 called warps. - Warp divergence. When threads of one warp take different branches of an
if, the hardware runs the branches one after the other with part of the warp inactive, so you lose parallelism. Fix it by making the branch condition uniform within a warp or restructuring the work. - Memory coalescing. When the threads of a warp read consecutive addresses in global memory, the hardware serves them with few memory transactions. Strided or scattered access needs many. Typical question: why is reading a matrix by rows fast and by columns slow? Answer: with row-major storage, neighboring threads should touch neighboring elements.
- Shared memory and bank conflicts. Shared memory is fast, on-chip memory managed by the programmer and visible to one block. It is split into 32 banks; if several threads in a warp hit different addresses in the same bank, the accesses are serialized. A standard trick is padding a tile by one column.
- CUDA cores vs Tensor Cores. CUDA cores handle general scalar floating-point and integer work. Tensor Cores are units that perform small matrix multiply-accumulate operations, in lower or mixed precision on many generations, and are what makes deep-learning matrix math fast. Be ready to say which GPU generation you know and which precisions it supports, and don’t state numbers you can’t back up.
- Reduction. A classic exercise is summing an array on the GPU: each block reduces its part in shared memory (halving the active threads each step), then the block results are combined. Be ready to talk about divergence and bank conflicts in that code.
- Occupancy and latency hiding. A GPU hides memory latency by switching between many resident warps, so too many registers or too much shared memory per block lowers the number of warps and can slow a kernel.
If the job lists CUDA, write a few kernels (vector add, matrix transpose with shared memory, reduction) and profile them. Reading about it is not enough for this round. NVIDIA’s CUDA documentation and its programming guide are the primary sources.
Machine learning questions
For AI-focused roles, expect fundamentals rather than trivia:
- Backpropagation. Compute the loss in a forward pass, then use the chain rule to get the gradient of the loss with respect to each weight, moving from the output back to the input, and update the weights with an optimizer such as gradient descent. Be able to derive it for one small layer.
- CNN vs RNN, and why transformers replaced RNNs for many tasks. CNNs use local filters shared across a grid (images). RNNs process a sequence step by step and carry a hidden state, which limits parallelism. Transformers use attention and process a whole sequence in parallel, which suits GPUs.
- Transfer learning. Start from a model trained on a large dataset and fine-tune it on yours, which needs less data and compute than training from scratch.
- Batch normalization. It normalizes a layer’s inputs per mini-batch, which usually allows higher learning rates and faster training. The original explanation (reducing “internal covariate shift”) has been disputed in later research, so say “it stabilizes and smooths optimization” rather than claiming the original reason is settled.
- Overfitting and how to detect and reduce it: validation loss rising while training loss falls; more data, regularization, dropout, early stopping.
System design
For experienced candidates, typical prompts are a distributed cache, a metrics or analytics pipeline, or a distributed file store. Structure the answer: requirements and scale, API, data model, the main components, then bottlenecks and failure modes (replication, consistency, eviction, backpressure). At NVIDIA, expect the discussion to lean toward performance: where is the time spent, what is the bandwidth limit, and what do you measure first?
Behavioral questions
Prepare four or five true stories and adapt them: a hard project, a disagreement with a teammate, learning something fast, a mistake and what you changed afterwards, and a time you improved performance or reliability with numbers you can defend. Use situation, action, result, and keep each to about two minutes. Don’t invent details; interviewers ask follow-ups.
How to prepare
- Practice 40 to 60 medium problems across lists, heaps, hash maps, trees and graphs, explaining aloud as you code. Our NVIDIA technical interview prep post goes through a study plan.
- If the role uses C++, solve problems in C++ and know the basics of memory, pointers, and concurrency.
- For CUDA roles, write and profile a handful of kernels.
- Read the job description line by line. Each listed skill is a likely interview topic.
- Prepare questions about the team’s work, since the team is what you will actually be joining.
