OpenAI Interview Questions — Page 67

OpenAI·Software Engineer·Onsite - System Design / Architecture

Jul 2026

System design round at OpenAI for a software engineering role, centered entirely on designing a Sora-style text-to-video generation platform. The question was massive and the interviewers clearly had a specific mental model they were probing toward, especially around failure handling and job state machines. Walked out unsure whether I'd gone deep enough on the parts that actually mattered.

Design a text-to-video generation platform similar to Sora, covering the user-facing API, job lifecycle, GPU worker scheduling, failure handling, artifact storage, safety enforcement, and observability.
A worker gets network-partitioned, the system declares it dead and retries the job elsewhere, the retry completes successfully, and then the original worker comes back online and tries to publish its result. How does your design prevent a double publish or double billing?
If 80% of a long-running GPU job completes and then the spot instance gets preempted, how do you avoid restarting the entire computation from scratch?
Inference finished but the post-processing stage (encoding, upscaling, watermarking) crashed. What do you re-run and what must you absolutely not re-run?
A single prompt consistently crashes every worker that picks it up. How does the system protect the rest of the fleet, and how do you handle billing for that job?
GPU utilization is sitting at 60% while job queues are full and wait times are rising. What are the likely causes and how does your monitoring help you figure out if the bottleneck is scheduling, the model, or hardware?
How would you make the job submission API idempotent so that a client retry on a timeout never creates a duplicate GPU job or triggers a double charge?
How do you enforce safety at both the prompt level and the generated frame level, and how do you handle watermarking and content provenance?

“This is the kind of question where you can spend 45 minutes and still feel like you only scratched the surface.”

View Post

OpenAI·Software Engineer·Onsite - System Design / Architecture

Jul 2026

OpenAI SWE interview that went deep on memory allocator design, starting from a basic first-fit implementation and pushing all the way through coalescing, best-fit optimization, and complexity trade-offs. Four parts total, each building on the last, and the follow-ups got pretty hairy toward the end.

Design and implement a simplified memory allocator with malloc and free operating over a single fixed-size heap array. Walk from a correct first-fit implementation to an optimized one, covering block layout, splitting, and per-operation complexity.
How should free handle adjacent free blocks, and what is the difference between external and internal fragmentation?
Propose a best-fit optimization for the allocator. What data structure makes the lookup efficient, and why is a plain min-heap not a clean fit?
Compare first-fit and best-fit on allocation time, metadata overhead, and long-run fragmentation behavior. When would you prefer each?
How would you make the allocator thread-safe, starting from a global lock and then reducing contention?
How do boundary tags enable O(1) coalescing without a prev pointer in the block header?
How would you detect heap corruption, such as through canaries or header checksums, without unacceptable overhead?

“This is the kind of question where you think you know it and then the details eat you alive.”

View Post

OpenAI·Software Engineer·Technical Phone Screen

Jul 2026

Got a coding problem at OpenAI for a software engineer role that was deceptively tricky to think through cleanly. The core problem was manageable but the follow-up about prefix-balanced scheduling added a whole layer I wasn't fully prepared for.

Design a scheduling system for a data labeling platform with tasks, AI models, and human annotators. Given counts for each entity type and a minimum assignment threshold k, return a list of [task, model, human] assignments such that every human appears in at least k assignments and no human is assigned the same task more than once.
Follow-up: modify your solution to return a prefix-balanced schedule, where at every prefix of the output the task-model usage counts differ by at most 1, and each human's per-model usage counts also differ by at most 1.

“Spent the first few minutes just making sure I understood the constraints, which was the right call.”

View Post

OpenAI·Software Engineer·Technical Phone Screen

Jul 2026

OpenAI software engineer interview focused on a persistent key-value store problem with some meaty follow-ups around storage and write-ahead logging. The core question was manageable but the follow-ups are where things got real.

Implement an in-memory key-value store with put, get, delete, serialize, and deserialize operations. Keys and values are arbitrary byte strings so you can't rely on delimiters.
The serialized data might be too large for a single file. How would you extend the persistence format to split data across multiple files or segments and still restore correctly?
Full rewrites on shutdown are expensive once the store grows. How would you add an append-only mutation log, replay it on startup, and decide when to compact it back into a snapshot?

“The delimiter thing is what trips people up.”

View Post

OpenAI·Machine Learning Engineer·Technical Phone Screen

Jul 2026

Interviewed for an ML Engineer role at OpenAI and got hit with a pretty involved algorithmic problem about version strings and a rate-limited API. Two-part question that escalated fast, and the second part especially required some real design thinking under pressure.

You have a list of version strings in the format {major}.{minor}.{patch} with zero-padded segments. Given an arbitrary list of these versions and an isSupported(version) API call, return the smallest version (by version ordering) that supports a feature. Support is not monotonic. How do you parse and compare versions, handle duplicates or invalid inputs, and what is the time and space complexity?
Now the isSupported API is rate-limited so you can't make O(N) calls. Support is still not globally monotonic, but you're guaranteed that for any supporting version, support will eventually reappear in the next patch group, the next minor group, and the next major group. Design a sub-linear algorithm to find the earliest supporting version. Walk through correctness, call count, and edge cases like no supporting version at all or very sparse support.

“My first instinct was just sort and scan, which is correct but I fumbled explaining the comparison logic for zero-padded segments out loud.”

View Post

OpenAI·Software Engineer·Technical Phone Screen

Jul 2026

OpenAI software engineering interview with a systems-focused coding problem. The question was about building a persistent key-value store from scratch with shard-based file storage, which sounds manageable until you actually have to think through all the edge cases live.

Design and implement a persistent key-value store that writes data to fixed-size shard files on disk. The store should support put, get, delete, shutdown (persist to disk), and restore (reload from disk). You're given encode/decode helpers for serialization.

“I spent the first few minutes just trying to nail down the in-memory index before even thinking about the file layout, which was probably backwards.”

View Post

OpenAI·Frontend Engineer·Technical Phone Screen

Jul 2026

Frontend coding round at OpenAI for a frontend engineer role. The whole thing was one meaty component design question about building a streaming chat UI, with a bunch of follow-ups that got progressively more painful the further in you went.

Build a minimal chat interface where the user submits a prompt and the assistant's response streams in token by token. Walk through the component structure, state management, and how you'd handle the incremental rendering.
How would you prevent duplicate submissions while a stream is still in progress, and what do you do about the request that's already running?
A response can be hundreds of small chunks. How do you keep the UI responsive and avoid performance problems from re-rendering on every single chunk?
What happens if a slow chunk from a previous request arrives after a newer request has already started?
How would you extend this to a multi-turn scrolling conversation while keeping the streaming bubble performant?
Walk through adding a Stop Generating button. What state changes and what do you actually cancel?
How would you handle auto-scroll-to-bottom behavior without yanking the user's scroll position if they've scrolled up to read earlier messages?
How would you make streaming text accessible to screen reader users, and how would you test the streaming behavior in a deterministic way?

“The state model tripped me up at first.”

View Post