OpenAI interview questions

Showing 211–240 of 342 results

• Fault-Tolerant Task Queue with Retry Cooldowns, a Dead-Letter Queue and DependenciesHard

  Implement an in-memory fault-tolerant task queue with enqueue, reserve, fail and a dead-letter queue, where each failed task waits out its own cooldown measured from the failure time and returns in its original enqueue order. A second part adds task dependencies, testing state modeling, efficient scheduling and careful edge-case handling.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Fault-Tolerant Work Queue with Leases, Fencing Tokens and DAG Task DependenciesHard

  Implement a fault-tolerant work queue in which workers claim tasks under expiring leases, crashed workers' tasks are reassigned, and late reports from stale workers are rejected, then add DAG dependencies with cycle detection. It tests leases, fencing tokens, topological release and delivery semantics.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Filter Bad Human AnnotationsMedium

  Tests the ability to detect and filter low-quality human labels in large-scale dataset pipelines by modeling annotator reliability, distinguishing genuine ambiguity from noise, and evaluating downstream model performance.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Find Minimum Compatible VersionMedium

  Implement an algorithm to find the earliest compatible software version while minimizing expensive compatibility-check API calls across partitioned version branches.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Find a Hidden Number When Each Comparison Answer Arrives One Call LateHard

  Find a hidden integer from 1 to n using a comparison API whose answers arrive one call late: each call submits a new guess but returns the result for the previous one. Build a correct search first, then reduce the worst-case number of calls. It tests binary search under delayed feedback and worst-case analysis.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Find the First Working VersionMedium

  This question tests the ability to combine custom comparison logic with a binary search approach to identify the first transition point in a monotonic sequence.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Follow Graph with Cheap Snapshots and Top-K Follow RecommendationsHard

  Build a one-directional follow graph that supports cheap snapshots and queries against past snapshots, then recommend the top k accounts a user should follow. It tests versioned data structures, snapshot semantics, two-hop graph traversal, heap-based top-k selection and scaling to highly connected accounts.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Follow One-Way Links to the Endpoint Node or the Last Node Before a Loop ClosesHard

  Given one-way links in which every node has at most one outgoing link, follow the links from a start node and return the endpoint where the walk stops, or the last node visited before the walk would revisit a node. Tests single-successor graph traversal, visited-node bookkeeping and loop edge cases.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• GPU Credit Ledger with Expiring Grants, Out-of-Order Operations and Fast BalancesHard

  Implement a GPU credit ledger with expiring grants, subtractions that spend the soonest-expiring credits first, and balance queries, where operations can arrive out of timestamp order. Then avoid recomputing from time zero on every query. It tests event replay, priority queues and checkpoint invalidation.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• GPU Credit Ledger: Spend Earliest-Expiring Credits First, Stop on OverdraftMedium

  A coding and design question about an in-memory GPU credit ledger that grants expiring credits, charges usage against the credit that expires soonest, and returns no balance once any charge overdraws the account. It tests data structure choice, expiry and boundary conventions, and optimizing the ledger for a very large number of credit changes.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Game Telemetry Windows: Match Counts, Live Sessions, Late EventsMedium

  Build an in-memory service that counts per-match actions inside a global 10-minute window, tracks each player's live client sessions from heartbeats and logouts, and stays correct when events arrive late. Tests bounded-memory eviction, amortized analysis, lazy deletion and exact window semantics.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Generate Data Labeling SchedulesMedium

  This question evaluates combinatorial reasoning and constructive algorithm design for generating constrained assignment schedules, including ensuring each human appears a minimum number of times, preventing duplicate human-task pairs, and managing valid ID ranges.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Hand-Rolled Backprop: Running Product and Stable Cross-EntropyHard

  Derive and implement, without an autodiff library, the backward pass of a running (cumulative) product in linear time without division, then a numerically stable softmax cross-entropy and its gradient. Tests chain-rule fluency, prefix/suffix tricks, and gradient checking.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Hand-Written Gradients: Prefix-Product Backward Pass and Stable Cross-EntropyHard

  Write gradients by hand: the forward and backward pass of the prefix-product operation, in linear time and without division so inputs may contain zeros, and a numerically stable softmax cross-entropy loss with its gradient in NumPy. It tests the chain rule, prefix and suffix products, and gradient checking.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Handle repeated churn in SQLHard

  This problem tests your ability to handle complex temporal data by identifying user churn and re-subscription events, then calculating metrics like tenure and churn count per user.

  OpenAIData ScientistData Manipulation (SQL/Python)Technical Screen
• Hiring manager call: walk through your past work, interests and latest projectHard

  A hiring manager asks you to describe what you have built, what you want to work on next, and the project you worked on most recently, then describes their own team. Tests whether you can tell a concise career story, separate your own contribution from the team's, and defend the technical decisions of a recent project in depth.

  OpenAISoftware EngineerBehavioral & LeadershipTechnical Screen
• How to answer common recruiter screen questionsHard

  How to prepare for an OpenAI software-engineering recruiter / HR phone screen. Covers the full set of common screen questions — self-intro, work-setup and sponsorship logistics, employment history and departure narrative, promotion and leadership-vs-coding deep-dives, an ambiguity STAR story, search-timeline and 'why OpenAI', referral context, and compensation — with model answers, a STAR framework, and the mistakes that sink candidates.

  OpenAISoftware EngineerBehavioral & LeadershipHR Screen
• How would you evaluate a free-trial A/B test?Medium

  Evaluates skills in A/B test design and causal inference within the Analytics & Experimentation domain, emphasizing precise metric definition (including guardrails), choice of analysis population (ITT vs per‑protocol), handling of post‑treatment selection, and interpretation of binary conversion and retention metrics; the abstraction level is technical and oriented toward intermediate-to-senior data scientists who must combine statistical rigor with product impact thinking. Commonly asked because it tests the ability to balance acquisition versus downstream retention and revenue, to identify typical analysis pitfalls (time-window errors, incorrect joins/denominators, leakage, peeking, and selection bias), and to translate experiment results into a business recommendation linked to value metrics like LTV and payback period.

  OpenAIData ScientistAnalytics & ExperimentationTechnical Screen
• Identify Bugs in Python Script for User AssignmentMedium

  This question evaluates a candidate's ability to detect bugs and data-quality risks in a Python script, testing competencies in code review, reproducible randomization, idempotency, logging, duplicate-exposure safeguards, and safe experiment-assignment logic.

  OpenAIData ScientistCoding & AlgorithmsOnline Assessment
• Implement 1NN with NumPyMedium

  Tests your ability to implement a fast, vectorized 1-Nearest Neighbor (1NN) classifier using NumPy, focusing on memory-efficient distance computations and tie-breaking.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Implement A Contiguous Memory Allocator With Free-Block CoalescingMedium

  Design a fixed-size contiguous memory allocator supporting allocation and deallocation with immediate adjacent free-block coalescing.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement A Mobile Chat Interface In An Existing CodebaseMedium

  Tests your ability to design and implement a streaming chat interface state manager in an existing mobile codebase, focusing on async token streaming, state modeling, cancellation, and error handling.

  OpenAIiOS EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement Chat Event CounterEasy

  This question evaluates data structures and algorithms competency, focusing on designing efficient in-memory counters and time-windowed event aggregation for (userId, chatId) pairs; it is categorized under Coding & Algorithms and has a practical implementation focus.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement Disease and Friend Snapshot ModelsHard

  This question evaluates skills in graph-based modeling and temporal state simulation as well as the design and implementation of snapshot-capable directed graph data structures, covering competencies in propagation and state transitions (including immunity, recovery, and death), efficient snapshotting, querying, ranking, and diffing of follow relationships. It is commonly asked to assess algorithmic reasoning, correctness under edge cases, and complexity-aware implementation; the problem belongs to the Coding & Algorithms domain and tests both conceptual understanding of dynamic graph behavior and practical application-level implementation of data structures and immutable snapshots.

  OpenAISoftware EngineerCoding & AlgorithmsOnsite
• Implement GPU credit ledgerMedium

  This question evaluates a candidate's ability to design efficient stateful systems and algorithmic data structures for tracking per-tenant resource balances, including handling idempotency, negative balance policies, concurrency, and persistence.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement IP Address ArithmeticHard

  Implement parsing, binary representation, arithmetic offsets, and canonical formatting for both IPv4 and IPv6 addresses and CIDR subnets.

  OpenAISoftware EngineerCoding & AlgorithmsOnsite
• Implement IPv4 and CIDR iteratorsMedium

  This problem tests your ability to manipulate IP address bit-representations and implement a custom iterator to traverse all addresses within a given CIDR block.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement KV store and plan type conversionsMedium

  This question evaluates proficiency in designing scalable, time-versioned key-value data structures and in graph-based shortest-path planning for costed type conversions, assessing algorithmic thinking, complexity analysis, and robustness under large-scale constraints in the Coding & Algorithms domain.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement KV store serializationMedium

  This question evaluates skills in binary serialization and deserialization, data encoding and layout, type tagging, endianness, checksumming, versioning for forward/backward compatibility, and algorithmic efficiency and space usage for an in-memory key-value store; it falls under the Coding & Algorithms domain.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement Masked Cross-Entropy with Label SmoothingMedium

  Implement a numerically stable, masked cross-entropy loss function with label smoothing and temperature scaling in NumPy, returning both the loss and analytical gradients.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen