Stage 1 · Hands-On Exploration

1 of 4

Cross an order into a live book, price what the sweep costs, and cancel out of one in constant time.

Raise the order size until the buy stops filling at the best offer, and watch what the average fill price does as each level runs out.

Market Microstructure

Limit Order Book & Market Impact Simulator

Spread: $0.02Mid: $100.02

PRICEASK SIZE

$100.08550

$100.05800

$100.04400

$100.03200

--- SPREAD $0.02 ---

$100.01300

$100.00700

$99.98450

$99.95600

Simulate Market Buy Order Impact:

Order Quantity150 units

Best Available Ask:$100.03

Executed VWAP:$100.030

Price Levels Swept:1 level(s)

Slippage Impact:+0 bps

This one has no automatic check. Work through it above, then carry on.

Market microstructure and order books· 2 of 3

Market microstructure and order books

Limit order book

Build an in-memory limit order book with price-time priority, O(1) cancellations, and crossing market order execution.

25 minute read

⚡

For the best experience: Download the native Atlas Desktop app for instant test running, native IDE sync, and 100% offline practice.

Download Desktop App→

A limit order book tracks all unexecuted limit orders submitted by market participants.

To handle high message throughput, matching engines organize bids and asks in sorted price levels, where each price level maintains a FIFO queue of resting orders.

Representation of order book state

An order book maintains two sides:

Bids: Buy orders sorted in descending order of price. The highest bid is the best bid.
Asks: Sell orders sorted in ascending order of price. The lowest ask is the best ask.

When a new buy order arrives with a price equal to or higher than the best ask, the matching engine does not add it to the bid queue. Instead, it immediately crosses the book, matching against resting ask orders in price-time sequence until either the incoming buy quantity is satisfied or no acceptable asks remain. Any remaining unfilled quantity is then posted to the bid queue.

Fast order cancellation

In live trading, quote updates and cancellations vastly outnumber executed trades. If cancelling an order requires scanning every queue in the order book, the search is $O(N)$ in the number of open orders.

Production matching systems track active orders in a hash map from order_id to order reference. Cancelling an order updates its active status or sets its quantity to zero in $O(1)$ time. When the matching engine encounters a zero-quantity order at the head of a queue during a fill pass, it discards the dead node lazily.

An ID set preserves every submitted identifier, so duplicate submissions remain a permanent error. A fully filled order is terminal, while a partially filled taker remains resting until its remainder is gone.

Exercise: build an order book

In this exercise, you will implement an in-memory OrderBook with FIFO price-time priority.

Your implementation must support:

Inserting limit orders with automatic crossing execution when prices cross.
Executing market orders against resting book liquidity and reporting any unfilled quantity.
Cancelling existing orders in $O(1)$ time.
Computing the best bid, best ask, midpoint price, and quoted spread.

A reused order ID always raises ValueError. A partially filled taker still has unfilled remainder, so it remains resting and cancellable; a fully filled maker cannot be cancelled or reused.

Market microstructure and order books

Limit order book

Build an in-memory limit order book with price-time priority, O(1) cancellations, and crossing market order execution.

25 minute read

⚡

For the best experience: Download the native Atlas Desktop app for instant test running, native IDE sync, and 100% offline practice.

Download Desktop App→

Coding Objective

Implement your solution in the editor on the right or work in your local IDE. All unit tests run against your code in real-time.

Language: Python 3.10+Runner: Local / Pyodide

Exercise

limit-order-book

8 tests, graded on your machine in about a second. Stuck for 35 minutes? The desktop app will offer you the reference solution.

solution.py

from __future__ import annotations

from dataclasses import dataclass, field
from enum import Enum
import time

class Side(str, Enum):
    BUY = "BUY"
    SELL = "SELL"

@dataclass(slots=True)
class Order:
    order_id: str
    side: Side
    price: float
    quantity: float
    timestamp: float = field(default_factory=time.time)

@dataclass(slots=True)
class Trade:
    taker_order_id: str
    maker_order_id: str
    side: Side
    price: float
    quantity: float
    timestamp: float = field(default_factory=time.time)

class OrderBook:
    """
    In-memory limit order book with price-time priority.

Invalid limit orders and market quantities must not mutate the book.
    An order ID can be submitted only once. A partially filled taker with remaining
    quantity is still resting and remains cancellable.
    """

def __init__(self) -> None:
        pass

def add_limit_order(self, order: Order) -> list[Trade]:
        """
        Insert a limit order. If it crosses existing orders, execute immediately.
        Remaining quantity is posted to the book.
        Reject a non-positive price or quantity by returning no trades.
        """
        raise NotImplementedError

def execute_market_order(self, side: Side, quantity: float) -> tuple[list[Trade], float]:
        """
        Execute a market order against the book.
        Returns a tuple of (executed_trades, unfilled_quantity).
        Reject a non-positive quantity by returning (no trades, original quantity).
        """
        raise NotImplementedError

def cancel_order(self, order_id: str) -> bool:
        """
        Cancel an open order by id in O(1) time.
        Returns True if open remainder was removed; False otherwise.
        """
        raise NotImplementedError

@property
    def best_bid(self) -> float | None:
        """Highest resting buy price, or None if no bids exist."""
        return None

@property
    def best_ask(self) -> float | None:
        """Lowest resting sell price, or None if no asks exist."""
        return None

@property
    def mid_price(self) -> float | None:
        """Arithmetic mean of best bid and best ask, or None if either is missing."""
        return None

@property
    def spread(self) -> float | None:
        """Difference between best ask and best bid, or None if either is missing."""
        return None

Or use the desktop app