Design Online Stock Brokerage System
Design an Online Stock Exchange system that allows users to place buy/sell orders, match trades, and track stock prices in real-time, using object-oriented design.
An Online Stock Exchange is a digital platform where investors can trade stocks and other financial instruments electronically. It serves as a marketplace that brings together buyers and sellers, facilitates order matching, and ensures smooth execution of trades in real time.
Modern stock exchanges also provide:
- Live market data and stock price updates
- Historical trade information
- Tools for portfolio and order management
- Support for various types of orders (e.g., market, limit)
In this chapter, we will explore the low-level design of an online stock exchange system in detail.
Lets start by clarifying the requirements:
1. Clarifying Requirements
Before starting the design, it's important to ask thoughtful questions to uncover hidden assumptions and better define the scope of the system.
Here is an example of how a conversation between the candidate and the interviewer might unfold:
Candidate: Should the system support only limit orders, or do we also need to handle market orders and stop-loss orders?
Interviewer: Let’s start with limit and market orders. We can skip stop-loss and more advanced order types for now.
Candidate: Should we support multiple stocks being traded simultaneously, or focus on a single stock for simplicity?
Interviewer: Multiple stocks should be supported. Each stock will have its own order book.
Candidate: How should the order matching engine behave? Should it follow price-time priority?
Interviewer: Yes, price-time priority is the standard and should be followed for matching buy and sell orders.
Candidate: Do we need to support partial order fulfillment if a match is not fully available?
Interviewer: Yes, if an order can be partially matched, it should be fulfilled partially and the remaining quantity should stay in the order book.
Candidate: Should we track real-time price updates and publish a trade feed for matched orders?
Interviewer: Yes, the system should publish trade events with relevant details for each match—symbol, price, quantity, timestamp.
Candidate: Do users need to have account balances or portfolios managed by the system?
Interviewer: Not for this version. We can assume a simulation environment where users place orders without account balance verification.
After gathering the details, we can summarize the key system requirements.
1.1 Functional Requirements
- Support trading of multiple stock symbols
- Allow users to place limit and market orders (buy or sell)
- Maintain an order book for each stock symbol
- Match orders using price-time priority
- Support partial matching of orders
- Update the order book after each match
- Publish real-time trade events for matched orders
- Allow users to cancel pending (unmatched) orders
- Provide APIs or console interfaces to view order book and trade history
1.2 Non-Functional Requirements
- Modularity: The system should be divided into components such as OrderBook, MatchingEngine, TradePublisher, and OrderService
- Scalability: The system should handle high-frequency trading and large volumes of concurrent orders across multiple stocks
- Extensibility: The design should support future enhancements like stop-loss orders, user accounts, risk checks, and position management
- Reliability: Ensure the order book and matching engine behave consistently under concurrent updates
- Performance: Order matching and trade publishing should be done in near real-time
- Maintainability: Code should follow object-oriented design principles and be easy to test and evolve
- Auditability: All order and trade events should be logged for future analysis and debugging