Start with the official guide
OpenAI publishes an interview guide, and it is more useful than most company career pages. It lays out the stages - application review, introductory calls, a skills-based assessment, final interviews and a decision - and gives rough timelines for each: about a week to hear back after the application, after each assessment, and after the final loop. References may be requested at the decision stage.
It also says what OpenAI is looking for in plain terms. The company describes itself as not credential-driven, hires both established experts and people it considers high-potential - quick to learn a new domain and produce results - and wants to see how you approach problems, make decisions and explain your reasoning. For engineering roles it names four things: well-designed solutions, high-quality code, optimal performance and good test coverage.
Everything below builds on that list. Where the detail comes from candidate reports on interview-prep sites rather than OpenAI, it is labelled as such, because formats vary by team and change over time.
The skills assessment: practical over clever
The guide says the assessment varies by team and may be pair coding, a take-home project or a technical test, and that some roles have more than one. Candidates commonly report HackerRank or CoderPad environments and problems that look like real work: debugging an existing function, extending a small codebase, or optimising code for readability as well as speed.
The practical framing matters for how you spend the hour. Read the whole problem before writing anything. State the interface you are going to build. Write the simplest correct version, then a couple of tests that pin its behaviour, and only then optimise. Interviewers in these rounds are reading your code as a future reviewer would; a fast solution with no structure and no tests scores worse than a clean one that is slightly slower.
# A practice pattern, not a known question: build, then pin with tests,
# then optimise. Interviewers read the tests as evidence you think about edges.
import time
from collections import defaultdict, deque
class SlidingWindowLimiter:
"""Allow at most `limit` events per `window` seconds, per key."""
def __init__(self, limit: int, window: float, clock=time.monotonic):
self.limit, self.window, self.clock = limit, window, clock
self.events = defaultdict(deque)
def allow(self, key: str) -> bool:
now = self.clock()
q = self.events[key]
while q and q[0] <= now - self.window:
q.popleft()
if len(q) >= self.limit:
return False
q.append(now)
return True
def test_limiter():
t = [0.0]
lim = SlidingWindowLimiter(limit=2, window=10, clock=lambda: t[0])
assert lim.allow("a") and lim.allow("a")
assert not lim.allow("a") # third call inside the window
assert lim.allow("b") # keys are independent
t[0] = 10.0
assert lim.allow("a") # oldest event has expiredThe final loop: four to six hours
Final interviews are virtual by default with an onsite option in San Francisco, and the guide describes them as designed to stretch you beyond your comfort zone. Candidate reports describe a mix of the following, weighted by level: a further coding round, usually harder and more open than the assessment; a system design round for most mid-level and senior roles; a refactoring round where you improve existing code; a project deep dive; and a behavioural round focused on mission alignment.
The refactoring round deserves its own practice. You are handed working but messy code and asked to make it better. The trap is rewriting everything. The strong approach is to read first, name the two or three problems that matter most - an unclear boundary, duplicated logic, a hidden performance cliff - make those changes in small steps, and keep behaviour identical. If there are no tests, writing one before you refactor is itself a signal.
For system design, expect to defend API shapes and data models as well as boxes and arrows. When the problem touches model serving, bring numbers: tokens per second, context length, memory per sequence. The arithmetic is covered later in this series.
The senior project presentation
For senior roles, candidates report a project deep dive that is sometimes a short presentation - four or five slides on a project you led. The structure that works is the one an engineering review would want: the problem and why it mattered, the options you considered, the one you chose and what it cost, the result with a number attached, and what you would do differently.
The follow-up questions are where the round is decided. Interviewers push on the decisions you made and the ones you did not get to make. Pick a project where you can answer three levels of 'why' on every major choice, and where you can say honestly what went wrong. A tidy story with no failures reads as either a small project or a rehearsed one.
Behavioural, mission, and the AI-tools rule
The guide asks candidates to review the OpenAI Charter, research publications and recent blog posts, especially those relevant to the team. Use that literally: have an informed view on something the team has shipped or published, and be ready to discuss trade-offs in it rather than praise it. The behavioural round also probes humility and collaboration, so prepare stories where you changed your mind because someone else was right.
On AI tools, the guide is explicit that there is no single rule. Some interviews allow them; others assess how you solve problems on your own, and the expectation for each is in your prep materials. If anything is unclear, ask your recruiter before the day. Practise both ways, because switching modes under pressure is harder than it sounds.
Finally, the guide's own reading list is worth taking seriously for anyone near the ML side: it points to the Deep Learning book and to Spinning Up in Deep RL. You will not be quizzed on chapters, but fluency with the fundamentals shows up in every design conversation.