NVIDIA·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Jun 2026

Summary

NVIDIA software engineering interview that leaned pretty heavily on Python internals and async patterns. Four distinct questions, no fluff, they clearly wanted to see if you actually understand what's happening under the hood rather than just knowing the syntax.

Questions Asked (4)

You're shown a Python helper class that repeatedly reads from an HTTP response stream and writes output. What is this class doing, and what are its responsibilities?

Technical Trade-offsAPI & Integrations

Author's notes

This one felt like a warmup but I overcomplicated it.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by describing the class's high-level purpose: it reads from an HTTP response stream in chunks and writes the output, likely to another stream or file. Then break down its responsibilities: managing the read loop, handling chunked data, ensuring proper resource cleanup, and possibly handling errors or backpressure. Finally, discuss trade-offs such as blocking vs non-blocking I/O and buffer management.

Pro tip: Mention that this pattern is common in streaming APIs and that the class likely abstracts away low-level socket operations, providing a clean interface for consumers. Highlight the importance of closing the response and handling exceptions to avoid resource leaks.

1. Identify the core functionality

Explain that the class reads from an HTTP response stream in a loop and writes the data to an output destination, effectively acting as a stream pump.

2. Break down responsibilities

List key responsibilities: initiating the read loop, handling chunked transfer encoding, writing data, and managing the lifecycle of the response (e.g., closing it).

3. Discuss error handling and edge cases

Mention how the class might handle network errors, timeouts, or incomplete reads, and ensure resources are released properly.

4. Analyze trade-offs and design choices

Talk about blocking vs non-blocking I/O, buffer size choices, and whether the class supports asynchronous operations or backpressure.

5. Relate to real-world usage

Connect the class to common use cases like downloading large files, streaming APIs, or proxying responses, and note how it fits into a larger system.

Key Points to Mention

Streaming data in chunks to avoid loading entire response into memory
Proper resource management: closing the HTTP response and underlying connection
Error handling: dealing with network failures, timeouts, and partial reads
Buffer management: choosing buffer size and handling backpressure
Blocking vs non-blocking I/O and potential for asynchronous support
Integration with HTTP libraries (e.g., requests, urllib3) and context managers

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

Here's a piece of async Python code that fetches multiple URLs concurrently. Find the race conditions, blocking calls inside the event loop, and any coroutines that aren't being awaited, then explain how you'd fix them.

Algorithms & Data StructuresRoot Cause AnalysisTechnical Trade-offs

Author's notes

This was the one that actually made me sweat.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by systematically scanning the code for common async pitfalls: unawaited coroutines, blocking calls inside async functions, and shared mutable state accessed without synchronization. For each issue, explain the root cause and propose a concrete fix, then discuss trade-offs such as performance impact and correctness guarantees.

Pro tip: Mention that you would use asyncio's debug mode and tools like aiomonitor or py-spy to detect blocking calls and unawaited coroutines in production, showing you think beyond just code review.

1. Identify unawaited coroutines

Look for calls to async functions without 'await' or 'asyncio.create_task', which return coroutine objects that never execute. Explain that these lead to silent failures and missing results.

2. Detect blocking calls in the event loop

Find synchronous I/O, CPU-bound operations, or time.sleep() inside async functions that block the event loop and prevent concurrency. Suggest using run_in_executor or async alternatives.

3. Spot race conditions

Check for shared mutable state (e.g., global variables, class attributes) modified by multiple coroutines without locks or atomic operations. Explain how interleaving can cause data corruption.

4. Propose fixes with trade-offs

For each issue, suggest a fix: await missing coroutines, replace blocking calls with async equivalents, and use asyncio.Lock or queues for shared state. Discuss performance and complexity trade-offs.

5. Summarize and validate

Recap the issues and fixes, and mention how you would test the corrected code (e.g., unit tests with asyncio, stress testing) to ensure concurrency safety.

Key Points to Mention

Unawaited coroutines produce RuntimeWarning and never run; use asyncio.create_task or await.
Blocking calls like time.sleep, requests.get, or heavy CPU work block the event loop; use aiohttp, asyncio.sleep, or run_in_executor.
Race conditions arise from unsynchronized access to shared resources; use asyncio.Lock, asyncio.Queue, or immutable data structures.
asyncio debug mode and tools like aiomonitor can help detect blocking calls and unawaited coroutines.
Trade-offs: locks add overhead and can cause deadlocks; offloading to threads has GIL limitations for CPU-bound tasks.
Proper error handling in async code: use try/except around await, and consider asyncio.gather with return_exceptions.

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

Implement a function list_matching_paths(root, pattern) that returns the absolute paths of all files under a given root directory that match either a glob or regex pattern.

Algorithms & Data StructuresAPI & Integrations

Author's notes

Went with os.walk and compiled the regex upfront, which felt right.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Clarify the pattern semantics (glob vs regex) and edge cases like symlinks and permissions, then outline a recursive directory traversal that compiles the pattern once and matches each file's absolute path. Discuss trade-offs between os.walk, os.scandir, and pathlib, and mention performance considerations for large directory trees.

Pro tip: Mention that you would compile the regex once outside the loop and use os.scandir for better performance, showing awareness of efficiency in large-scale systems like NVIDIA's.

1. Clarify Requirements

Ask whether the pattern is glob or regex, whether matching should be on the full path or filename, and how to handle symlinks, hidden files, and permission errors.

2. Choose Traversal Method

Decide between os.walk, os.scandir, or pathlib.Path.rglob based on performance and readability; justify your choice.

3. Compile Pattern

If regex, compile the pattern once before traversal; if glob, use fnmatch or pathlib's glob methods appropriately.

4. Traverse and Match

Recursively traverse the directory tree, and for each file, compute its absolute path and test against the pattern.

5. Handle Edge Cases and Return

Skip or log errors for inaccessible files, resolve symlinks if needed, and return the list of matching absolute paths.

Key Points to Mention

Use os.scandir for efficient directory traversal due to its lower overhead compared to os.walk.
Compile regex patterns once outside the loop to avoid repeated compilation overhead.
Use os.path.abspath or pathlib.Path.resolve to get absolute paths, being mindful of symlink resolution.
Handle permission errors gracefully with try-except blocks to avoid crashing on inaccessible directories.
Consider using fnmatch for glob patterns or re for regex patterns, and clearly document the expected pattern format.
For large directory trees, consider generators or yielding results to reduce memory usage.

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

How would you safely read a large CSV file, accounting for dialect detection, encoding issues, and memory constraints, then compute basic aggregates while handling errors gracefully?

System DesignTechnical Trade-offsRoot Cause Analysis

Author's notes

I talked through chunked reading with pandas and then they pushed back asking what I'd do without pandas.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements: file size, expected aggregates, and error tolerance. Then outline a streaming approach using chunked reading with dialect and encoding detection, followed by incremental aggregation and robust error handling. Emphasize trade-offs between memory, speed, and accuracy.

Pro tip: Mention that you would first sample the file to detect dialect and encoding, then use that to configure a streaming parser, avoiding loading the entire file into memory. Also, discuss how you would handle malformed rows by logging and skipping, and provide summary statistics of errors.

1. Clarify Requirements and Constraints

Ask about file size, expected aggregates, error tolerance, and performance requirements to tailor the solution.

2. Detect Dialect and Encoding

Use a sample of the file to infer delimiter, quote character, and encoding (e.g., via chardet or Python's csv.Sniffer).

3. Stream and Parse with Chunking

Read the file in chunks using a streaming parser, applying the detected dialect and encoding, to keep memory usage low.

4. Compute Aggregates Incrementally

Update aggregate values (sum, count, average, etc.) as each chunk is processed, avoiding storing all data.

5. Handle Errors Gracefully

Catch parsing errors per row, log them with context, skip malformed rows, and continue processing; optionally collect error statistics.

Key Points to Mention

Use of streaming/chunked reading to handle files larger than memory
Dialect detection using csv.Sniffer or similar, with fallback to defaults
Encoding detection with libraries like chardet or charset-normalizer, and handling BOM
Incremental aggregation to compute sums, counts, averages without storing all data
Error handling strategies: try/except per row, logging, skipping bad rows, and reporting error rates
Trade-offs between sampling for detection vs. full scan, and between strict vs. lenient error handling

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