Openai·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say

Jun 2026

Summary

Infrastructure Engineer interview at OpenAI that centered almost entirely on building a mini query engine from scratch. Pretty design-heavy for what I expected to be a coding round, and the discussion kept expanding into territory I wasn't fully prepared for.

Questions Asked (1)

Design and implement a simple in-memory SQL-like query engine that supports filtering records by fields like name, age range, and ID. Walk through your data model, how you represent predicates, query execution strategy, and how you'd extend it with AND/OR logic, sorting, and projection.

System DesignData ModelingTechnical Trade-offs

Author's notes

This one sprawled way more than I expected.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then present a clean data model and predicate abstraction that supports extensibility. Walk through a simple execution strategy (e.g., full scan with predicate pushdown) and discuss trade-offs, then outline how to add AND/OR, sorting, and projection via composable operators.

Pro tip: Emphasize that you'd start with a simple, correct implementation and then optimize based on profiling, showing you value pragmatism over premature optimization. Also, mention that you'd design the predicate interface to be easily serializable and composable, which is crucial for building complex queries.

1. Clarify requirements and constraints

Ask about data volume, query complexity, performance needs, and whether updates are needed. This shows you think before coding.

2. Design the data model and predicate representation

Propose a record structure (e.g., map or struct) and an interface for predicates with methods like evaluate(record). Discuss how to represent field comparisons and logical operators.

3. Outline query execution strategy

Describe a simple execution engine that iterates over records, applies predicates, and returns matches. Mention potential optimizations like indexing or predicate pushdown.

4. Extend with AND/OR, sorting, and projection

Explain how to compose predicates using composite patterns (e.g., AndPredicate, OrPredicate) and add sorting (e.g., comparator) and projection (e.g., field selection) as post-processing steps.

5. Discuss trade-offs and future extensions

Talk about performance vs. simplicity, memory usage, and how you'd add features like joins or aggregation. This demonstrates foresight.

Key Points to Mention

Use of an interface for predicates to allow composition and extension (e.g., Predicate with evaluate method).
Composite pattern for AND/OR logic (e.g., AndPredicate, OrPredicate) to build complex conditions.
Execution strategy: full scan with early termination, and potential indexing for performance.
Sorting via comparator and projection by selecting specific fields to reduce data transfer.
Trade-offs between simplicity and performance, and when to optimize (e.g., based on profiling).
Extensibility: how to add new operators or data types without modifying core engine.

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