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

SeniorPrefer not to say

Jun 2026

Summary

System design round at OpenAI for a software engineering role. The whole thing was one big question about building a CI/CD platform from scratch, GitHub Actions style. A lot of ground to cover and I think I spread myself too thin on some parts.

Questions Asked (1)

Design a CI/CD system similar to GitHub Actions, where users define workflows in YAML files and the system triggers jobs on events like pushes, pull requests, or schedules. Cover the full stack: workflow model, event ingestion, job scheduling, runner fleet management, artifact and log storage, secrets handling, retries, and scaling under bursty load.

System DesignTechnical Trade-offsAPI & Integrations

Author's notes

This is a monster of a question and I underestimated how much they wanted me to go wide before going deep.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then walk through the end-to-end architecture from workflow definition to execution, emphasizing event-driven design and decoupling. Dive into each component (event ingestion, scheduler, runners, storage, secrets) with trade-offs, and finish with scaling and reliability strategies for bursty workloads.

Pro tip: Explicitly call out idempotency and exactly-once semantics for job execution, and discuss how you'd handle poison messages and dead-letter queues—these are often overlooked but critical in CI/CD systems.

1. Clarify Requirements and Scale

Ask about expected scale (jobs/day, concurrent runners), latency requirements, multi-tenancy, and supported event types. Establish assumptions to guide design decisions.

2. High-Level Architecture

Sketch the main components: event ingestion, workflow parser/validator, job scheduler, runner fleet, artifact/log storage, and secrets manager. Explain how they interact via queues and APIs.

3. Deep Dive into Key Components

Detail the workflow model (YAML schema, DAG of jobs), event ingestion (webhooks, polling, message queue), scheduling (priority queues, resource matching), and runner management (auto-scaling, isolation).

4. Address Reliability and Security

Cover retries with exponential backoff, idempotency, dead-letter queues, secrets encryption and rotation, and isolation (VMs, containers, sandboxing).

5. Scaling and Trade-offs

Discuss scaling strategies for bursty load (horizontal scaling, queue buffering, spot instances), storage choices (object store for artifacts, log aggregation), and trade-offs (cost vs. latency, consistency vs. availability).

Key Points to Mention

Event-driven architecture with message queues (e.g., Kafka, SQS) for decoupling and burst absorption
Workflow DAG representation and dependency resolution for job scheduling
Runner fleet auto-scaling and isolation using containers or VMs, with warm pools for latency reduction
Artifact storage in object stores (S3) with lifecycle policies, and log streaming to centralized systems (ELK, Loki)
Secrets management using vaults (HashiCorp Vault, AWS Secrets Manager) with encryption at rest and in transit
Idempotency, retries with backoff, and dead-letter queues for fault tolerance

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