Job search
GPU Compiler vs. CUDA Systems Jobs: Match Code Generation, Drivers, and Performance Experience
Three current employer roles, a completed synthetic measurement-scope correction and three fictional evidence packets distinguish GPU software ownership layers.
A GPU compiler job changes how programs become executable GPU code. A CUDA systems job may instead own the driver, runtime interfaces, GPU kernels or the infrastructure around an accelerated workload. Match your experience to the layer you would change. Distinguish calling CUDA from developing its driver, and writing C++ from implementing a compiler transformation.
We reviewed three public employer descriptions and current NVIDIA documentation on October 20, 2026. The role audit and completed claim correction below distinguish code generation, operating-system integration and measured workload performance. Candidate backgrounds and numerical examples are explicitly fictional. We did not run CUDA, install GPU tooling, execute a hardware benchmark or apply for a job.
Publication update — October 23, 2026: AMD requisition 88607 now returns HTTP 404. Its compiler responsibilities remain a dated example of MLIR/LLVM and code-generation ownership. We have not verified a replacement vacancy, and this example should not be treated as an open application route.

LandOffer publishes this guide. You can browse recent roles on LandOffer.ai for a broader comparison, then identify the actual implementation and operating responsibilities in each employer description.
Read the object of the engineering work
Read what the posting asks you to implement, debug or operate. “Implement compiler passes” points toward transformations and code generation. “Develop virtual-memory interfaces” points toward systems behavior. “Tune attention kernels” points toward workload execution and performance. All three can involve C++, debugging and GPU architecture, so language lists alone are a weak discriminator.
A compiler engineer needs to reason about what a transformation preserves as well as what it improves. A driver engineer needs to reason about interfaces and system state. A kernel or performance engineer needs to connect a workload's correctness and execution behavior to the claimed improvement. The boundaries overlap, but the evidence supporting each claim differs.
Be careful with the word kernel. A CUDA compute kernel is work executed on the GPU. Kernel-mode operating-system software is a different meaning of the term. A posting that names both may span multiple layers; it does not mean experience with one automatically establishes experience with the other.
Compiler ownership includes transformations and generated code
AMD's Senior Staff Compiler Software Engineer, requisition 88607 in San Jose, described MLIR and LLVM optimizations, intermediate representations, lowering pipelines and target-specific code generation. It also covered fusion, tiling, memory planning, kernel scheduling and analysis across frameworks, runtimes and hardware.
Build your evidence around the compiler behavior you changed so a reviewer can identify your implementation responsibility. A useful account identifies the input representation, transformation, conditions under which it is valid, resulting code and regression evidence. Merely compiling an application with an existing compiler does not show that ownership. Nor does a smaller source file prove that the emitted GPU code became faster.
This role also included technical leadership and broad performance work. Do not treat a single introductory LLVM exercise as equivalent to a senior staff scope. A relevant project can establish a foundation while leaving target architecture, production scale and leadership gaps plainly visible.
AMD's posting mentioned HIP, CUDA or similar programming-model experience. That is a cross-stack experience signal; it does not make CUDA and AMD's GPU software platform interchangeable. Identify the employer's actual target and toolchain before treating a familiar acronym as an exact environment match.
Driver work is a systems responsibility
NVIDIA's Senior Software Engineer — CUDA Driver, requisition JR2014725, listed Santa Clara and five-plus years of systems software experience. Its requirements included C, complex software stacks, operating-system interfaces for threads and virtual memory, and architecture concepts such as interrupts and memory-mapped I/O. Kernel-mode and Linux systems experience appeared among distinguishing skills.
That points toward a different evidence package from a fast matrix-multiplication notebook. Explain a system interface you designed or debugged, a concurrency problem, its failure conditions and the validation that accompanied the change. If the work was on a different device, retain that context instead of calling it CUDA-driver development.
NVIDIA's CUDA Driver API documentation places the runtime above a lower-level, handle-based driver API. It describes objects such as contexts, modules, streams and device memory. Calling those interfaces is not the same as implementing the driver behind them. An application can exercise an API extensively while its author has never modified the platform's driver code.
We read the job page with an Apply control on the check date. It also said applications would be accepted at least until September 4, 2026. That earlier minimum date is not a newly verified future deadline. Reopen the requisition when making a decision; this review does not guarantee how long it will remain available.
CUDA performance can extend beyond one kernel
The Software Engineer — Kernels/CUDA (C++) listing on the xai job board displayed SpaceXSI branding and Palo Alto/Seattle locations during our review. Its responsibilities included CUDA kernel tuning with CUTLASS, Tensor Cores and Nsight, alongside GPU-cluster infrastructure. It also named bottlenecks across memory, networking, filesystems and multi-GPU operation.
That is broader than writing one correct GPU function. A workload can be limited by data movement, synchronization, communication or surrounding infrastructure. A faster isolated operation supports a claim about that operation; a training-step or application-level claim needs a measurement of that wider workload.
NVIDIA's asynchronous execution guide explains that launches can return before device work finishes and describes synchronization and events. Consequently, timing how quickly the host enqueues work can answer a different question from timing completed GPU work. State exactly what starts and stops your measurement.
The CUDA introduction also distinguishes a successful launch-parameter check from proof that the kernel executed successfully. Correctness and completion need their own evidence. Avoid presenting a successful API call as a completed result or a profiler screenshot as proof of an unexplained speedup.
Completed role audit: choose the relevant evidence
This is a bounded comparison of the three inspected descriptions, not a survey of all GPU jobs or a ranking of hiring difficulty.
| Employer role inspected | Core ownership | Evidence that would address it | Common overstatement to avoid |
|---|---|---|---|
| AMD 88607, compiler | IR transformations, lowering and generated-code/performance behavior | A compiler change, validity conditions, regression cases and target analysis | Calling ordinary application compilation compiler development |
| NVIDIA JR2014725, driver | CUDA features and OS/hardware-facing systems behavior | Threading, virtual-memory or device-interface implementation and debugging | Calling CUDA API usage driver implementation |
| xai-board Kernels/CUDA role, SpaceXSI branding | Kernel tuning plus production GPU infrastructure | Correctness checks, profiler interpretation, comparable timing scope and operational work | Calling an isolated kernel result an end-to-end system speedup |
Use the table to select the work you can discuss deeply. A job can span two or three columns, in which case you need to distinguish your strongest evidence from the responsibilities you would still learn. A title containing systems does not settle that balance.
Keep level and location separate from technical relevance. San Jose, Santa Clara and the listed Palo Alto/Seattle locations are not universal remote permissions. The compiler example is explicitly senior staff, while the driver example names substantial systems experience. This audit did not establish a common level mapping, remote arrangement or sponsorship policy across these employers.
Completed claim correction: a synthetic performance record
Consider this entirely fictional teaching record, with invented durations in milliseconds. It is not measured GPU data. We checked only the arithmetic locally using Python 3.12.14; no CUDA kernel, GPU compiler or GPU driver was executed for this article.
An engineer's draft says: “Made the GPU system 25% faster.” Their stipulated record contains a kernel duration changing from 0.90 to 0.72 ms and a full pipeline duration changing from 1.40 to 1.29 ms. It also includes a 0.08 ms host enqueue duration, which has not been shown to represent completed GPU work.
| Fictional record item | Completed interpretation | Allowed claim in this teaching example |
|---|---|---|
| Kernel: 0.90 → 0.72 ms | Old/new duration is 1.25; latency reduction is 20% | A 1.25× kernel speedup, or 20% lower kernel duration, under the stipulated scope |
| Pipeline: 1.40 → 1.29 ms | Old/new is about 1.09; latency reduction is about 7.86% | About 7.86% lower pipeline duration in this invented record |
| Host enqueue: 0.08 ms | Completion and comparability are not established | No GPU execution-time claim |
| Device, precision, dimensions and repetition details | Not supplied in the fictional input | No portable, reproducible or cross-device benchmark conclusion |
The corrected note reads: “In this synthetic example, kernel duration falls by 20%, while the recorded pipeline duration falls by approximately 7.86%. The two measurements describe different scopes.” That correction removes the unsupported system-wide claim and the ambiguous use of faster.
A real performance submission would need the actual workload, device and software environment, numerical correctness criteria, measurement boundaries and repeatable results. It would also need to explain whether initialization, compilation, transfer and synchronization were included. Those missing facts are not filled in by the arithmetic.

Do not add overlapping operation times as though all work occurred serially. Likewise, do not compare a warmed-up kernel with a baseline that includes initialization and call the difference an optimization. These are questions to resolve from the actual experiment, not results demonstrated by this invented record.
Complete a candidate packet around owned work
Inez is a fictional compiler engineer who has maintained C++ LLVM passes for a CPU target. She has a regression case for a miscompilation, the patch and review discussion, and before/after generated-code inspection. She has not implemented a GPU backend or profiled a CUDA kernel.
Her completed packet starts with the miscompilation reproducer, the CPU-pass patch and regression coverage. Her note reads: “Fixed a CPU-target transformation bug, added the reproducer to regression coverage and inspected generated code after the change.” She retains CPU-target in the sentence. She does not upgrade it to GPU code generation because the prospective employer works on GPUs.
She uses the AMD description as a technical comparison, with GPU lowering and architecture-specific performance recorded as gaps. The senior staff scope also remains a separate level question. NVIDIA's driver work and the CUDA-infrastructure role are not her first priorities solely because she writes C++.
Owen is a fictional Linux systems engineer with device-interface, thread synchronization and virtual-memory debugging experience. He has not worked on NVIDIA's driver. His completed packet prioritizes the driver description: it contains a race reproducer, the interface change and a record of the tested operating-system/device environment. He labels those artifacts with their actual device and leaves CUDA programming-model implementation unclaimed.
Priya is a fictional CUDA application engineer with real-in-the-example kernel changes, correctness checks and profiling records. Her packet prioritizes kernel/performance ownership, and separates isolated-kernel results from full application measurements. She does not use the synthetic numbers above as her own evidence, claim driver ownership from API calls or claim compiler-pass experience from generated PTX inspection.
These are three completed routing decisions, each with a retained statement and a boundary. They do not establish that anyone qualifies for a specific opening or should receive a particular level. A small learning project can close part of a knowledge gap without becoming a production accomplishment.
Choose the layer before tailoring the application
For compiler roles, foreground transformations and generated-code correctness. For driver roles, foreground systems interfaces, concurrency and hardware interaction. For CUDA kernel and performance roles, foreground correct computation, credible measurement and the workload scope you actually improved. Then inspect where the selected posting combines these responsibilities.
Attach a patch, debugging record or correctly scoped performance report to the central tasks of one requisition before tailoring your resume. To broaden the search, browse recent roles on LandOffer.ai, and keep the distinction between owned work, transferable experience and untested claims intact.


