What Data Streams Do You Need to Build a US Stock Order Imbalance Market-Making Strategy?

Intro

I’ve been building automated market-making bots for US equities as a side quantitative project, and I ran into a frustrating, widespread pain point most new algo traders hit:
My backtest results looked rock-solid on local historical data, but once I deployed the code to cloud servers for paper trading, quoting logic went haywire. Risk metrics spiked continuously, and bid/ask spreads drifted far away from reasonable market levels.
I spent hours auditing my imbalance formulas and quote adjustment logic, only to find zero bugs in the core algorithm. The real root cause was incomplete, unsynchronized market data pipelines.

In this post, I’ll break down the full suite of data streams required for reliable order book imbalance strategies, walk through common data architecture pitfalls, share a standardized cloud processing workflow, and include a minimal WebSocket subscription code snippet using AllTick API for real-time US market feeds. This guide is tailored for self-taught quant devs, algo engineers, and anyone building micro-structure trading systems.

Core Data Standards for Order Imbalance Market-Making

Order imbalance strategies dynamically adjust bid/ask quotes based on real-time supply-demand shifts in the limit order book. US stock liquidity behaves drastically differently across pre-market open, regular session, and closing auction windows, so your data pipeline must satisfy four non-negotiable requirements:
Full Level 2 order book depth coverage
Single-level bid/ask snapshots are useless for calculating accurate imbalance ratios. You need complete volume aggregates for every price tier on both sides of the book.
Raw tick-by-tick trade stream integration
Order books only display resting liquidity intent; executed tick data reveals genuine capital buying/selling pressure hidden behind temporary spoofed orders.
Unified timestamp synchronization across all feeds
Mismatched timestamps between book snapshots and trades break imbalance calculations entirely, creating false micro-structure signals.
Archived historical market data for multi-scenario validation
You need historical tick and minute bar archives to test strategy performance under low-liquidity, high-volatility, and opening/closing auction market regimes to avoid overfitting.

Missing or delayed data of any type creates massive divergence between backtest curves and live/paper trading performance.

Common Data Pipeline Pitfalls for New Quant Developers

After chatting with dozens of self-taught algo builders, these four architectural mistakes consistently derail imbalance strategy deployments:
Only consuming top-of-book data, missing full Level 2 depth
This skews your core imbalance metric, as hidden large orders on distant price tiers are completely ignored.
Subscribing to order book feeds without tick trade streams
You cannot distinguish transient fake orders from sustained institutional buying/selling activity.

Separate, unsynchronized ingestion for book, trade, and volume data
No centralized timestamp alignment leads out-of-order data records that corrupt real-time factor computations.
No persistent historical data archiving
You can only test your strategy on narrow market windows and cannot validate robustness across full market cycles.
Most developers sink dozens of hours tweaking mathematical formulas while ignoring foundational data infrastructure—this is why so many algos fail when moved out of backtesting environments.

Standard Cloud Data Preprocessing Pipeline (24/7 Paper Trading Ready)

This universal workflow works for long-running cloud-based quant systems:

1. Establish persistent WebSocket connections to ingest raw market data into volatile in-memory cloud cache
2. Automated cleaning layer filters out outlier price jumps and duplicate duplicate broadcast records
3. Cross-align all book, tick, and volume streams using the unified timestamp standard
4. Normalize all dataset field schemas, then split the pipeline into two branches: real-time computation and historical archiving
5. Real-time branch feeds the imbalance market-making strategy module for live quote generation; archived branch writes time-series storage for batch backtesting

Minimal WebSocket Subscription Demo Code

This base snippet establishes a live US equity tick feed subscription. Production deployments require additional modules for timestamp validation, persistent Redis caching, automatic reconnection, and time-series database writes.

import websocket
import json

# US stock real-time trade subscription payload
subscription_payload = {
    "type": "transaction_quote",
    "symbol": "market.usstock"
}

def on_open(ws):
    ws.send(json.dumps(subscription_payload))

def on_message(ws, raw_message):
    market_data = json.loads(raw_message)
    # Extend here: cache writes, timestamp alignment logic
    print(market_data)

if __name__ == "__main__":
    ws_client = websocket.WebSocketApp(
        "wss://quote.alltick.co/websocket-api",
        on_open=on_open,
        on_message=on_message
    )
    ws_client.run_forever()

Final Thoughts

Complex mathematical imbalance formulas and quote adjustment logic are only the surface layer of a viable market-making strategy. The backbone of consistent, reliable paper/live trading performance is a complete, time-synchronized low-latency data pipeline.

Combining Level 2 depth, tick execution archives, historical market records, aggregated volume metrics, and cross-feed timestamp normalization resolves nearly all common discrepancies between backtesting and live algorithm behavior.
Prioritizing robust data infrastructure over endless formula iteration drastically shrinks performance gaps and makes your strategy’s output far more trustworthy for real capital deployment.