← Paxos Interview Insights

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

SeniorPrefer not to say
May 2026

Summary

System design round at Paxos for a software engineer role, centered entirely on a market surveillance platform for financial exchanges. The problem was meaty and had some real nuance around routing constraints that I didn't fully appreciate until I was already mid-answer.

Questions Asked (1)

Q1

Design a market surveillance platform where financial exchanges can submit trading orders, and the system detects potential market manipulation using pre-built detection algorithms that emit events asynchronously. The system must support two routing constraints: all orders from a given trader must be processed by the same algorithm instance, and all orders from a given exchange must go to a single dedicated instance. Each algorithm type can be independently scaled, and the system must handle very high throughput with strong availability guarantees.

System DesignTechnical Trade-offsAPI & Integrations
Author's notes

The routing constraints are where I got turned around.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then propose a high-level architecture with an ingestion layer, a routing layer that enforces the two constraints, and a processing layer with independently scalable algorithm instances. Emphasize how partitioning and consistent hashing solve the routing constraints while maintaining high throughput and availability, and discuss trade-offs around ordering, fault tolerance, and exactly-once processing.

Pro tip: Explicitly call out that the two routing constraints are essentially partitioning requirements: trader-based partitioning for algorithm instances and exchange-based partitioning for dedicated instances. Mention that you'd use a consistent hashing ring with virtual nodes to handle scaling and rebalancing without violating the constraints.

1. Clarify Requirements and Scale

Ask about expected throughput (orders per second), latency requirements, number of exchanges, traders, and algorithm types. Confirm availability and consistency needs, and whether ordering per trader/exchange is required.

2. High-Level Architecture

Propose an ingestion layer (e.g., API gateway or message queue) that receives orders from exchanges, a routing layer that directs orders to the correct algorithm instance based on trader and exchange, and a processing layer where algorithm instances consume and process orders asynchronously, emitting events to a downstream event bus.

3. Enforce Routing Constraints

Use consistent hashing to partition orders by trader ID for algorithm instances, ensuring all orders from a trader go to the same instance. For exchange-dedicated instances, route all orders from an exchange to a single instance, potentially using a separate topic or queue per exchange.

4. Scalability and Availability

Scale each algorithm type independently by adding instances and rebalancing partitions. Ensure high availability through replication, leader election, and fault-tolerant message queues. Discuss handling of hot partitions and rebalancing without violating routing constraints.

5. Trade-offs and Failure Handling

Discuss trade-offs between consistency and availability, ordering guarantees, and exactly-once vs at-least-once processing. Describe failure scenarios (e.g., instance crash) and recovery strategies, such as replaying from a durable log.

Key Points to Mention

  • Consistent hashing with virtual nodes for trader-based partitioning
  • Separate topics/queues per exchange for dedicated instances
  • Asynchronous event emission via a message bus (e.g., Kafka)
  • Independent scaling of algorithm types using consumer groups
  • High availability through replication and leader election
  • Exactly-once processing semantics and idempotency

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