NVIDIA runs a team-owned loop rather than one centralized process, so the shape varies sharply by org: software candidates get a HackerRank/pen-paper screen heavy on C/C++ output questions, operating systems and aptitude, then one to five interviews that mix DSA with low-level systems reasoning (pointers, memory layout, bit twiddling, threads and mutexes, cache behaviour) and a deep resume grill. Hardware and ASIC candidates sit a distinct written paper covering registers, counters, Verilog and static timing analysis alongside a surprising amount of plain DSA, and interviewers often revisit the exact questions the candidate skipped on the paper. Deep-learning, architect and solutions-architect tracks skip coding almost entirely in favour of long domain deep-dives (CUDA kernels, inference serving, tensor parallelism) and multi-person panels stretched over weeks.
These 22 writeups cover software engineering, systems software, hardware engineering and other roles. 20 of them were posted under a pseudonym (Reddit, GeeksforGeeks or forum handles), so we could not verify the authors’ identities.
Typical rounds
2.31-5 range
Outcomes shared
5/7offer / not
Most common round
Technical
Sources span
2019 - 2026
Most frequently reported · Data structures & algorithms(12), Past projects(11), Operating systems(8), Aptitude(7), Arrays & strings(7)
Nvidia’s official process
NVIDIA frames hiring in three stages: search and apply (it suggests applying to the five roles that best match your background, and says applications get a response within a couple of weeks); 'Let's Meet', a mix of phone, video and in-person interviews of roughly 30-60 minutes each, with HackerRank coding exercises for technical roles, an explicit ban on unapproved outside tools such as ChatGPT during interviews, and a hard requirement that every full-time candidate complete an onsite in-person interview at an NVIDIA office before an offer can be considered; and 'Join the Team', with most candidates hearing a decision within a matter of weeks of their first interview. Final-stage candidates are offered an optional 15-minute non-binding 'Insider Chat' with a Community Resource Group member.
Three coding problems, including in-place pairwise and k-group linked-list reversal and a k-th largest element in a BST without modifying it, plus C++ output questions about constructor and destructor ordering.
Covered · Linked lists, Trees, Graphs, C++ output questions
2
Logical reasoningTechnical
Combinatorics and dice-probability questions, a coin-flip puzzle, and an analysis of a naive recursive exponentiation routine where the candidate had to derive its complexity and then optimize it.
Covered · Aptitude, Probability, Puzzles, Time complexity
3
Technical interviewTechnical
A GPU-flavoured tensor layout conversion between NCHW and NHWC stored flat in a 1D array, a rotated-sorted-array search, an O(1) min-stack, an aligned-malloc implementation, and questions on struct padding and offsets.
Project retrospective on challenges and lessons learned, C++ output questions on virtual functions and copy constructors, and a multi-threaded C program where two threads must alternate printing even and odd numbers in strict sequence.
Covered · Past projects, Concurrency, OOP, C++ output questions
5
Technical + behavioralTechnical
More project ownership questions, then a drill into mutex versus semaphore, what goes wrong when two threads touch the same resource, and the four conditions for deadlock plus avoidance strategies.
Covered · Past projects, Concurrency, Operating systems
A one-hour HackerRank test of two coding questions plus 25 MCQs spanning C/C++ fundamentals, OS, DSA, probability and permutations, and DBMS. Five students from the college cleared it.
Covered · Data structures & algorithms, Operating systems, DBMS, Probability
2
Technical interviewTechnical
The interviewers pulled three questions straight off the online test and asked the candidate to explain the reasoning, then moved to an anagram-substring check and tree depth, pass-by-value versus reference, stack overflow and recursion, and why row-major traversal of a 2D array beats column-major on cache. Finished with a semaphore-ordering problem for two printing threads.
Opened with motivation for switching jobs, then a discussion of hardware interrupts and a puzzle-style task of finding the minimum of three numbers without using comparison operators.
Covered · Operating systems, Bit manipulation, Behavioral
2
Technical interviewTechnical
Static versus dynamic linking, the meaning of a static function in C, bit set/toggle exercises, finding the element occurring an odd number of times, binary search on a rotated sorted array, and deep-copying a linked list with random pointers without extra space.
Covered · Bit manipulation, Linked lists, Arrays & strings, Operating systems
Twenty-one MCQs on C/C++, programming and data structures with several compiler-output questions, plus one coding question. Roughly 25 candidates reached the interview stage across intern tracks.
Covered · Data structures & algorithms, Compiler design, C++ output questions
2
Code-review technicalTechnical
An unusual round: the candidate was handed roughly 250 lines of existing C code implementing a spiral binary-tree-to-doubly-linked-list conversion and had to read it, spot the bugs (a call-by-value slip, missing stack overflow and underflow guards, a typecast error), then fix them live and discuss how to avoid the overflow checks entirely via dynamic allocation.
A resume-driven manager round: past internship and projects run live on screen, then computer-architecture questions on the memory hierarchy and L1/L2/L3 caches, GPU versus CPU architecture and CUDA memory management from the candidate's own project, hyperthreading and logical processors, and the phases of compilation.
A mid-senior engineer spent the hour on the candidate's day-to-day embedded work, then linked-list reversal, determining stack and heap growth direction in memory, IPC mechanisms and the pros and cons of D-Bus, Boost Asio, a missing-number problem, and how std::vector grows internally.
Senior engineer round: hex-string to decimal conversion, detecting little- versus big-endian architecture, more D-Bus follow-ups, implementing memcpy including the overlapping-memory case, and a digit puzzle where a four-digit number times four equals its reverse.
The manager covered RISC versus CISC and ARM versus x86, cross-compilation, counting set bits two different ways with trade-offs, constructors and destructors plus delete versus free, object creation in C++, and gdb usage, returning again to D-Bus.
Covered · Computer architecture, OOP, Debugging, Past projects
Two medium-to-hard competitive-programming/DSA questions plus aptitude, with results returned in two to three days.
Covered · Data structures & algorithms, Aptitude
2
Technical interviewTechnical
An in-person round with two interviewers. First a trie-based problem in the style of deduplicating identical folder subtrees, where the candidate debugged a failing run live, then a partition-array-to-minimize-sum-difference DP problem worked from brute force up to the optimal solution.
A 90-minute HackerRank test of 12 questions, two full DSA problems and ten shorter data-structure questions, to be completed within 48 hours of receiving the link.
Covered · Data structures & algorithms
2
Technical interviewTechnical
An hour on two problems: adding two numbers represented as linked lists, and reconstructing a tree from a list of parent-child pairs including identifying the root.
Covered · Linked lists, Trees
3
Technical interviewTechnical
One medium graph problem followed by a set of cloud/infrastructure scenario questions where the candidate had to propose solutions rather than write code.
Covered · Graphs, Scalability, Customer scenarios
4
ManagerialHiring manager
Detailed probing of the candidate's two-year-long current project, scenario questions, one closing DP problem, and a discussion of role expectations and career plans.
Covered · Past projects, Dynamic programming, Behavioral
A pen-and-paper 50-MCQ hour split across C/C++ (pointers, recursion, increment operators), OS theory (critical section, memory management, deadlock), complexity-focused DSA, and a tough quant section on probability, permutations and speed-distance.
Covered · Operating systems, Data structures & algorithms, Aptitude, Pointers
2
Technical interviewTechnical
A two-hour marathon: twenty minutes on projects and ML basics, then roughly an hour of OS grilling (scheduling and Gantt charts, multithreading on a uniprocessor, thread versus process switching, semaphores and wait/signal, paging, MMU, logical versus physical addressing, user versus kernel mode, system calls), then C/DS questions on static variable storage, the process memory image, stack growth direction and memory leaks, and finally probability puzzles.
A 50-minute HackerRank test of negatively-marked MCQs on aptitude, maths and C, plus two straightforward DSA questions in C. Only five of 20-25 test-takers advanced.
Covered · Aptitude, Data structures & algorithms, Pointers
2
Panel technicalPanel
Three interviewers took turns in separate windows over an hour: deleting the k-th node from the end of a linked list, struct versus class, implementing memcpy, a timing question about whether 100 one-millisecond iterations really take 100ms, a number-series puzzle, pointer arithmetic variants on an array, setting and clearing a bit in a 32-bit integer, and a water-jug measuring puzzle. Three of five candidates advanced that night.
Covered · Linked lists, Pointers, Bit manipulation, Operating systems, Puzzles
Introduction and work-history discussion followed by a multi-part Python question centred on parsing.
Covered · Past projects, Arrays & strings
2
Hiring managerHiring manager
Previous projects plus standard behavioural questions.
Covered · Past projects, Behavioral
3
Problem solvingTechnical
Easy-to-medium string manipulation in C/C++ with the STL explicitly off-limits, then designing a simple hashmap from scratch, again without STL containers.
Covered · Arrays & strings, Low-level design
4
System architectureSystem design
An architecture conversation grounded in the team's actual project rather than a generic design prompt.
Covered · System design, Domain knowledge
5
Problem solvingTechnical
Resume discussion and a few coding questions, though the candidate felt this interviewer was disengaged.
Covered · Resume deep-dive, Data structures & algorithms
Technical phone screen with hiring managerPhone screen
The hiring manager opened with a deep dive into the candidate's CUDA work, asking about specific kernels, optimizations and the hard parts, then followed up on model serving and inference engines such as vLLM, exact personal contributions, and what skills they wanted to build next. Closed with one clean-code DSA question on serializing and deserializing a binary tree.
Covered · CUDA, Domain knowledge, Trees, Past projects
A 60-minute campus-run offline test of aptitude, C-language and two coding questions. The candidate notes the test was easy enough that the shortlist was fiercely competitive.
Covered · Aptitude, Pointers, Data structures & algorithms
2
Technical interviewPanel
An hour-long video call with two panellists that leaned conceptual: machine-level reasoning about memory management, pointers, data types, integer overflow, function calls and addressing modes, a heavy OS block on synchronization, mutexes, race conditions, user versus kernel mode, semaphores and scheduling, plus two moderate DSA questions and motivation questions.
Covered · Past projects, Operating systems, Concurrency, Memory layout, Data structures & algorithms
Two medium coding questions plus medium-level OS, hard computer-organisation-and-architecture and C++ output questions. A 60 percent score was the cutoff to advance.
Covered · Data structures & algorithms, Operating systems, Computer architecture, C++ output questions
2
Technical interviewTechnical
Current role and responsibilities, then a domain question about which scheduling algorithms suit autonomous vehicles and why, followed by three easy-to-medium coding questions.
Covered · Operating systems, Domain knowledge, Data structures & algorithms
3
Technical interviewTechnical
How the call stack works during recursion, an iterative stack-based in-order traversal with complexity analysis, and a hardware-flavoured C problem: implement 32-bit multiplication on a microprocessor whose ALU only supports 16-bit multiply. The candidate could not finish the last one and was rejected.
Covered · Trees, Memory layout, Bit manipulation, Computer architecture
4
ManagerialHiring manager
Listed in the candidate's outline of the loop but not reached, as they were rejected earlier.
Basic aptitude and computer-science questions plus one coding problem counting palindromic substrings across an array of strings.
Covered · Aptitude, Arrays & strings, Data structures & algorithms
2
Face-to-face interviewTechnical
Three problems: a three-way partition sort, generating all possible full binary trees, and a synchronization exercise making two threads alternate execution k times without stopping either thread.
Twenty-eight MCQs spanning aptitude, OOP, computer networks and OS, plus two DSA questions, one of which required detecting a power of two from its binary representation using regex in C specifically. The candidate rated the assessment 4 out of 5 for difficulty.
A single resume-heavy round covering hackathon work and team coordination, one array-reduction DSA problem, a pointer-arithmetic C question, a discussion of how to parallelise merge sort with threads, and OS basics on threads and memory management.
Covered · Past projects, Arrays & strings, Pointers, Concurrency, Operating systems
A negatively-marked 50-minute paper of 21 fill-in-the-blank questions dominated by registers, counters, Verilog and two static-timing-analysis questions, but with a surprising sprinkling of plain DSA (binary search, DFS) and time-consuming aptitude puzzles. Most core-branch candidates finished 14-16 questions.
Covered · Digital design, Verilog, Static timing analysis, Puzzles, Data structures & algorithms
2
Technical interviewTechnical
A one-hour online round that started with a screen-shared walkthrough of the candidate's mecanum-wheel forklift project, including an unexpected detour into the ML component and a debate about using DSP correlation instead. The interviewers then opened the candidate's own answer sheet, asked why specific questions were left blank, and re-asked those topics live: swapping two registers using only boolean gates, cascaded mod-3/mod-4/mod-5 counter output frequency, a doubling-money puzzle, and finally setup/hold violations and identifying the critical path, which the interviewer taught on the spot before asking for optimizations.
Covered · Past projects, Digital design, Counters, Static timing analysis, Puzzles
A one-candidate, two-interviewer online session that the candidate described as relaxed rather than pressured, revisiting the time complexity of a problem from their earlier HackerRank test.
Covered · Data structures & algorithms, Time complexity
A single video call with an engineer covering the candidate's resume projects and CPU design, including how pipelining can raise a design's achievable clock frequency.
Covered · Past projects, Computer architecture, Digital design
An online round that opened on hardware topics but pivoted into software: complexity analysis of code snippets, how to reduce that complexity, and puzzles. The candidate was caught out by how software-weighted a hardware-titled interview turned out to be.
Covered · Domain knowledge, Time complexity, Puzzles
Basic computer-architecture questions on CPU pipelining plus C++ questions on data structures and pointers, with a resume project used as the anchor for the Verilog/RTL design discussion. The candidate had heard nothing back a month later.
Covered · Computer architecture, Pointers, Verilog, Past projects
Two separate Teams calls spread over weeks, one with a project member and one with the project lead, covering resume experience and architecture fundamentals.
A four-person panel across separate sessions on deep-learning architecture and GPU-specific concepts such as tensor parallelism. The candidate found the questions vaguely posed and the terminology mismatched with the accelerator world they came from, and rated the whole two-month process poorly.
Covered · Deep learning, Tensor parallelism, Domain knowledge
A conversational manager screen focused on prior projects and experience rather than any structured exercise.
Covered · Past projects, Resume deep-dive
2
Specialist technicalTechnical
A technical conversation with a specialist, which the candidate described as straightforward but highly non-standardized and largely conversational. Two weeks passed with no decision.
NVIDIA runs a team-owned loop rather than one centralized process, so the shape varies sharply by org: software candidates get a HackerRank/pen-paper screen heavy on C/C++ output questions, operating systems and aptitude, then one to five interviews that mix DSA with low-level systems reasoning (pointers, memory layout, bit twiddling, threads and mutexes, cache behaviour) and a deep resume grill. Hardware and ASIC candidates sit a distinct written paper covering registers, counters, Verilog and static timing analysis alongside a surprising amount of plain DSA, and interviewers often revisit the exact questions the candidate skipped on the paper. Deep-learning, architect and solutions-architect tracks skip coding almost entirely in favour of long domain deep-dives (CUDA kernels, inference serving, tensor parallelism) and multi-person panels stretched over weeks.
What topics does Nvidia test in interviews?
Commonly reported topics include Data structures & algorithms, Operating systems, Concurrency, Pointers, Memory layout, Computer architecture.
These guides summarize public, first-hand interview experiences shared by candidates. They describe the shape of each loop and the topics that came up, not a leaked question bank, and every experience links back to its original source. Processes change often; treat this as directional prep, not a script.