Software Engineering Fundamentals interview questions

Showing 781–810 of 1208 results

• Design an Extensible Simulation EngineHard

  This problem tests object-oriented design patterns and modular architecture by requiring the implementation of a simulation engine that remains agnostic to the specific rules of a two-player turn-based game.

  OpenAIMachine Learning EngineerSoftware Engineering FundamentalsOnsite
• Design an In-Memory Key-Value CacheHard

  Implement a thread-safe in-memory key-value cache supporting capacity bounds, LRU eviction, and per-key time-to-live (TTL) expiration.

  OpenAIMachine Learning EngineerSoftware Engineering FundamentalsTechnical Screen
• Dispatch Parcels to Delivery Drones That May Go Silent Mid-FlightMedium

  Build an in-process dispatcher that hands delivery parcels to drones, reclaims a parcel when its drone goes silent, rejects stale reports from a drone that already lost its parcel, and quarantines parcels that fail too many times.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Durable Session Cache: Byte Checkpoints, Segments, Thread SafetyHard

  A three-part exercise building a durable in-memory session cache: serialize entries to length-prefixed bytes and checkpoint them to disk, split the checkpoint into size-capped segments that reassemble by concatenation, then discuss making the class thread-safe. Tests byte-level encoding, exact round-tripping, and concurrency reasoning.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Expiring GPU Credit Ledger with Out-of-Order Events and Point-in-Time BalanceMedium

  A two-part coding exercise to build a GPU credit ledger with expiring grants, usage deducted earliest-expiration-first, out-of-order events and balance queries at any timestamp, then avoid replaying from time zero on every query. It tests event ordering, heap use, checkpointing and invalidation when late events arrive.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain JS threading and useState vs useRefHard

  This question evaluates understanding of JavaScript's execution model and concurrency mechanisms (including worker-based threading) along with React state-management semantics, specifically the behavioral differences between useState and useRef.

  OpenAISoftware EngineerSoftware Engineering FundamentalsHR Screen
• Explain KV cache in Transformer inferenceMedium

  This question evaluates understanding of KV cache mechanisms in Transformer inference, including attention-state caching, memory and latency trade-offs, and engineering optimizations for autoregressive decoding.

  OpenAIMachine Learning EngineerSoftware Engineering FundamentalsOnsite
• Explain what torch.distributed.barrier doesHard

  This question evaluates understanding of PyTorch distributed synchronization primitives, process coordination, and concurrency control in distributed training workflows.

  OpenAIMachine Learning EngineerSoftware Engineering FundamentalsOnsite
• Extensible card-hand ranking: three of a kind, flush, pair and a discard ruleMedium

  A three-part object-oriented coding exercise built around a card game: rank hands by three of a kind, pair and high card, insert a flush category, then add a discard rule that removes hands that are not a pair, returning a log of each game. It tests extensible design, deterministic tie-breaking and absorbing rule changes cleanly.

  OpenAIApplied ScientistSoftware Engineering FundamentalsOnsite
• Fault-Tolerant Task Queue with Retries, a Dead-Letter Queue and Task DependenciesHard

  Implement an in-memory fault-tolerant task queue with enqueue, reserve, complete and fail operations, retries up to a configurable attempt limit, and a dead-letter queue for tasks that keep failing. A second part adds dependencies between tasks, testing state-machine design, efficient readiness tracking and handling of failed dependencies.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• 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
• 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
• 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
• 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
• 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 a GPU credit ledger with expiring grants and out-of-order operationsMedium

  Implement a GPU credit ledger with grant, subtract and get-balance operations, where grants expire and spending draws from the soonest-expiring grant first. Operations can arrive out of timestamp order, and a follow-up asks how to avoid replaying the whole history from time zero on every query in production.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Implement a Recoverable In-Memory Key-Value StoreMedium

  This problem tests your understanding of durability, logging, and data persistence in an in-memory system.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement a Set with Readable SnapshotsHard

  Design and implement a versioned set data structure that supports membership modifications, instant snapshotting, and historical point-in-time queries efficiently.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Implement a Simple Memory AllocatorMedium

  This question evaluates low-level memory management and allocator design skills, including block header layout, free-list/data-structure choices, pointer arithmetic, fragmentation concepts, and analysis of time/space complexity.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Implement a fault-tolerant work queue that never loses tasks when workers failMedium

  Implement an in-process work queue that never loses a task when the worker holding it crashes, stalls or reports an error. It tests task state tracking, detecting silent workers, rejecting late reports from workers that lost a task, bounded retries for tasks that always fail, thread safety, and deterministic tests built on an injected clock.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement an Extensible Chatbot AppMedium

  This question evaluates a candidate's ability to design extensible object-oriented systems, covering interface-based architecture, dependency injection, per-conversation state management, and decoupled dispatch logic.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement malloc and free over Fixed Memory, Then Make Both LogarithmicHard

  Implement malloc and free for a fixed range of memory in Python, first with a simple list of blocks and then with logarithmic-time operations backed by a third-party sorted container. It tests block splitting and merging, choosing ordered indexes for allocation and neighbor lookup, and keeping parallel structures consistent.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• In-Memory Key-Value Store with Crash Recovery from a Log and Concurrent AccessHard

  Implement an in-memory key-value store, make it recover from a log file after a crash, including a half-written final record, and make it correct and fast under many concurrent threads. It tests write-ahead logging, crash consistency, compaction, and lock design with group commit.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Indexed Vector as a Linked List with Checkpoints Every k NodesHard

  Implement an indexed dynamic sequence of strings, in the sense of an array list, that supports inserting at a position and reading by position. Starting from a plain singly linked list, build a linked list with a checkpoint every k nodes so reads cost O(k), and keep the checkpoints correct as insertions shift positions.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Key-Value Store Persistence: Length-Prefixed Bytes, Size-Capped Chunks, Thread SafetyHard

  A three-part key-value store exercise: serialize keys, values and their lengths into bytes and persist them on shutdown, split the saved data into chunks of a given maximum size, and discuss making the existing code safe for multithreaded use. It tests byte-level encoding, correct restore and concurrency reasoning.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Lab Robot Job Dispatcher with Backoff, Quarantine and PrereqsHard

  Implement an in-memory job dispatcher where failed jobs wait out a per-job backoff, keep their original queue position, and get quarantined after repeated failures, then add prerequisite jobs with cascading quarantine. Tests state modeling, dual-heap scheduling, and online topological ordering.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Lease-Based Job Queue for Flaky Render WorkersMedium

  Build an in-process job queue that hands out time-limited leases. A job is never lost when a worker crashes, hangs or fails, and jobs that always fail are dead-lettered after a retry limit. Tests state machines, fencing tokens, thread safety and clock-injected tests.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen