← Waymo Interview InsightsMachine Learning Engineer

Waymo·Machine Learning Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say
Jun 2026

Summary

Interviewed for an ML Engineer role at Waymo and got hit with a pretty technical deep-dive on GPU/kernel-level stuff. Not the typical ML theory round I was expecting.

Questions Asked (3)

Q1

How would you approach optimizing a CUDA kernel for better performance?

Technical Trade-offsSystem Design
Author's notes

I talked through occupancy, warp divergence, and memory access patterns but felt like I was listing buzzwords more than actually reasoning through a real scenario.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by profiling the kernel to identify bottlenecks, then systematically apply optimizations based on the limiting factor (memory, compute, or latency). Emphasize an iterative, measurement-driven process and discuss trade-offs between different techniques.

Pro tip: Always mention that you validate optimizations with profiling tools like Nsight Compute and consider the end-to-end impact, not just kernel speed. This shows you understand real-world ML systems where data movement and integration matter.

1. Profile and Identify Bottlenecks

Use profiling tools (e.g., Nsight Compute, nvprof) to measure kernel execution time, memory throughput, compute utilization, and occupancy. Determine whether the kernel is memory-bound, compute-bound, or latency-bound.

2. Optimize Memory Access Patterns

Ensure coalesced global memory accesses, use shared memory for data reuse, and minimize bank conflicts. Consider using vectorized loads (e.g., float4) and leveraging read-only cache (__ldg).

3. Improve Compute Efficiency

Reduce instruction overhead by using fast math intrinsics, avoiding divergent branches, and increasing arithmetic intensity. Consider loop unrolling and using tensor cores if applicable.

4. Tune Launch Configuration and Occupancy

Adjust block size, grid size, and shared memory usage to maximize occupancy and hide latency. Use CUDA occupancy calculator and experiment with different configurations.

5. Iterate and Validate

Re-profile after each change to measure impact, ensure correctness, and avoid regressions. Consider end-to-end performance and integration with other system components.

Key Points to Mention

  • Profiling tools like Nsight Compute or nvprof to identify bottlenecks
  • Memory coalescing and shared memory usage to improve bandwidth
  • Occupancy and launch configuration tuning (block size, grid size)
  • Instruction-level optimizations (loop unrolling, fast math, avoiding divergence)
  • Trade-offs between different optimizations and their impact on other metrics
  • End-to-end performance and integration with ML pipelines

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q2

How does memory layout affect kernel performance, and what strategies would you use to optimize it?

Technical Trade-offsAlgorithms & Data Structures
Author's notes

Coalesced access and avoiding bank conflicts came to mind immediately.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by explaining how memory layout impacts kernel performance through factors like coalescing, bank conflicts, and cache behavior. Then, discuss specific optimization strategies such as data layout transformations, tiling, and using shared memory. Finally, tie it back to ML workloads at Waymo, emphasizing trade-offs and practical considerations.

Pro tip: Quantify the impact: mention that a poorly coalesced access pattern can reduce effective bandwidth by up to 10x, and always profile before optimizing to avoid premature tuning.

1. Explain the impact of memory layout

Describe how memory access patterns (coalesced vs. strided), alignment, and data locality affect kernel performance, including cache hit rates and memory bandwidth utilization.

2. Identify common bottlenecks

Discuss typical issues like uncoalesced global memory accesses, shared memory bank conflicts, and poor cache utilization that degrade kernel performance.

3. Propose optimization strategies

Outline techniques such as data layout transformations (e.g., SoA vs. AoS), memory access coalescing, tiling/blocking, using shared memory, and vectorized loads.

4. Connect to ML workloads

Relate these optimizations to ML-specific operations like matrix multiplications, convolutions, and attention mechanisms, highlighting how layout choices affect performance.

5. Discuss trade-offs and measurement

Emphasize the importance of profiling (e.g., using Nsight, nvprof) to identify bottlenecks and the trade-offs between different optimization strategies.

Key Points to Mention

  • Memory coalescing and its impact on global memory bandwidth
  • Shared memory bank conflicts and padding techniques
  • Data layout transformations: Structure of Arrays (SoA) vs. Array of Structures (AoS)
  • Tiling/blocking to improve cache reuse
  • Vectorized memory accesses (e.g., float4)
  • Profiling tools and iterative optimization

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q3

What is kernel fusion and when would you use it?

Technical Trade-offsSystem Design
Author's notes

Explained reducing memory round-trips by merging ops into a single kernel pass.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by defining kernel fusion as combining multiple operations into a single GPU kernel to reduce memory traffic and launch overhead. Then explain when to use it: when operations are memory-bound, have compatible data layouts, and fusion doesn't introduce excessive register pressure or reduce parallelism. Finally, discuss trade-offs and give an example relevant to ML workloads, such as fusing element-wise operations or activation functions.

Pro tip: Mention that fusion is not always beneficial—over-fusing can hurt performance due to register spilling or reduced occupancy. Also, highlight that modern compilers like XLA and TensorRT automate fusion, but understanding the manual trade-offs is crucial for custom kernels.

1. Define kernel fusion

Explain that kernel fusion is a technique where multiple operations are combined into a single kernel to minimize memory bandwidth usage and kernel launch overhead.

2. Explain the benefits

Discuss how fusion reduces global memory reads/writes, improves data locality, and decreases launch latency, leading to better performance for memory-bound workloads.

3. Identify when to use it

Describe scenarios: element-wise operations, reduction followed by element-wise, or when intermediate results are large and memory-bound. Avoid fusion when operations are compute-bound or have conflicting resource requirements.

4. Discuss trade-offs and limitations

Mention potential downsides: increased register pressure, reduced occupancy, longer compilation times, and difficulty in debugging. Emphasize the need to profile and measure.

5. Provide a concrete example

Give an ML example, such as fusing a convolution with batch normalization and ReLU, or fusing element-wise additions in a residual block, to illustrate practical application.

Key Points to Mention

  • Reduction in memory bandwidth usage and kernel launch overhead
  • Applicability to memory-bound operations and element-wise chains
  • Trade-offs: register pressure, occupancy, and compilation complexity
  • Automated fusion in frameworks like XLA, TensorRT, and TVM
  • Example: fusing Conv-BN-ReLU or residual additions
  • Importance of profiling to determine fusion benefit

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.