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

SeniorPrefer not to say

Apr 2026

Summary

System design round at OpenAI for a software engineer role, centered entirely on designing a chess game from scratch. Pretty deep dive, way more than I expected for a single question.

Questions Asked (1)

Design the object-oriented architecture for a chess game. Cover the core entities, legal move generation, special moves like castling and en passant, check/checkmate/stalemate detection, draw conditions, move history, and undo/redo functionality.

System DesignTechnical Trade-offsData Modeling

Author's notes

This question has a lot more surface area than it looks.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by identifying the core entities (Board, Piece, Player, Move) and their relationships, then design the move validation and game state management. Emphasize extensibility for special moves and draw conditions, and discuss trade-offs between simplicity and performance.

Pro tip: Demonstrate deep understanding by discussing how to represent the board (e.g., 8x8 array vs. bitboards) and the implications for move generation and performance. Also, mention the importance of separating game rules from UI for testability.

1. Identify Core Entities and Relationships

Define classes like Board, Piece (with subclasses), Player, Move, and Game. Establish how they interact, e.g., Board contains squares, Game manages turns and state.

2. Design Move Generation and Validation

Outline how each piece generates pseudo-legal moves, then filter for legality (e.g., not leaving king in check). Discuss handling special moves like castling and en passant with specific conditions.

3. Implement Game State Detection

Explain algorithms for check, checkmate, stalemate, and draw conditions (threefold repetition, fifty-move rule, insufficient material). Consider efficient state tracking.

4. Manage Move History and Undo/Redo

Use a command pattern or memento to store moves and board states. Discuss how to implement undo/redo by reverting moves or restoring snapshots.

5. Discuss Trade-offs and Extensibility

Compare design choices (e.g., inheritance vs. composition for pieces, board representation) and how they affect performance, memory, and ease of adding new rules.

Key Points to Mention

Board representation: 2D array vs. bitboards, and their impact on move generation speed and memory.
Piece hierarchy: using inheritance (e.g., Piece -> Pawn, Knight) or composition (e.g., movement strategies) for flexibility.
Special move handling: castling (king and rook not moved, no pieces between, not in/through check), en passant (pawn just moved two squares, capture as if one square).
Check/checkmate/stalemate detection: generating all legal moves for the current player; checkmate if king in check and no legal moves, stalemate if not in check and no legal moves.
Draw conditions: threefold repetition (track board states), fifty-move rule (halfmove clock), insufficient material (e.g., king vs. king).
Undo/redo: command pattern with execute/undo methods, or storing board snapshots; consider memory vs. speed trade-offs.

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