HFT Landscape & Market Microstructure

High-frequency trading is not forecasting. It is a race: two bots running the same idea finish in the order their messages reach the matching engine. Before you write a line of C++ you need to know what you are racing for — a place in a queue — and what it is worth.

• Read a central limit order book the way the matching engine reads it: two sorted sides, price first, then time.
• Compute the four numbers your bot actually trades on — spread, mid, microprice, obi — and say which way each of them leans.
• Explain, with a number, why a 10 µs bot beats a 100 µs bot even when both are right about the direction.
• Get a C++ client onto the arena's LATENCY board and read your own p50 / p99 / p99.9.

1What is it? Four participants and one data structure

Every modern equity, futures and crypto venue runs the same thing: a central limit order book — resting orders on two sides, matched by rules that fit on an index card. Everything else in this course is a consequence of those rules and of the fact that several people are trying to obey them faster than you.

The four numbers, and what each one leans on

// book_metrics.cpp — real, compilable C++20
#include <algorithm>
#include <cstdio>

struct Metrics { double mid, spread, micro, obi; };

constexpr Metrics compute(double bid_px, double bid_sz,
                          double ask_px, double ask_sz) noexcept {
    const double sz = bid_sz + ask_sz;
    return Metrics{
        .mid    = 0.5 * (bid_px + ask_px),
        .spread = std::max(0.0, ask_px - bid_px),   // locked/crossed -> 0
        .micro  = sz > 0.0 ? (ask_px * bid_sz + bid_px * ask_sz) / sz
                           : 0.5 * (bid_px + ask_px),
        .obi    = sz > 0.0 ? (bid_sz - ask_sz) / sz : 0.0};
}

constexpr bool near(double a, double b, double eps = 1e-9) noexcept {
    return (a > b ? a - b : b - a) <= eps;
}

// the balanced-book sanity check, moved to compile time
static_assert(compute(100.00, 500, 100.02, 500).obi == 0.0);
// NOT ==: micro is 100.01000000000001, mid is 100.00999999999999
static_assert(near(compute(100.00, 500, 100.02, 500).micro,
                   compute(100.00, 500, 100.02, 500).mid));

int main() {
    const auto m = compute(100.00, 800, 100.02, 200);
    std::printf("mid=%.4f spread=%.4f micro=%.4f obi=%.4f\n",
                m.mid, m.spread, m.micro, m.obi);
    // mid=100.0100 spread=0.0200 micro=100.0160 obi=0.6000
}

Order types: you may fix the price, or fix the fill, not both

Every order type is a position on one trade-off. A limit order fixes your price and leaves the fill uncertain; a market order fixes the fill and leaves the price uncertain. Pick a type and see where it sits.

2How it works: run the book yourself

This is a working central limit order book with price-time priority. Post a limit order and it joins the FIFO queue at its price — behind everything already there. Send a market order and it walks the other side, oldest order first at each level. Watch your queue_ahead, then press Reprice and watch what repricing costs you.

3Why it matters: 10 µs versus 100 µs, in fills

Here is the payoff, and it is arithmetic, not attitude. You and a rival see the same book update at the same instant and both decide to post the same limit order at the same price. The engine does not know who is cleverer. It timestamps arrivals. The slower order sits behind the faster one, and when a taker arrives with less quantity than the queue, only the front of the queue gets paid.

The arena is the live market, and the LATENCY board is the grade

The venue, the feed and the matching engine are already running; your bot is just another client on the wire, speaking JSON over a WebSocket. You override one hook, on_book, and every order you send from inside it is timestamped from feed-decode to send. That microsecond number is what the LATENCY board ranks — at p50, p99 and p99.9.

// include/hft_bot.hpp — the one hook that matters
void on_book(const std::string& symbol,
             double bid, double ask, double mid,
             double microprice, double obi) override {
    if (bid <= 0.0 || ask <= 0.0) return;      // need two sides
    if (ask - bid < 0.02) return;              // spread too tight
    // orders sent from here are latency-stamped for you
    if (obi > 0.4) buy_limit(symbol, 1, bid);
}

4Five ways week one goes wrong

These are the mistakes that survive all fifteen weeks if nobody names them now. Open them.

5Check yourself

Three questions, instant feedback, nothing recorded.

6Do the work