Case study: custom software
A trading platform that simulated millions of trades to find the few that win
Months of paper trading across crypto, sports, and weather, distilled into a live book with a highly significant return on every dollar traded.
This is a quantitative trading platform that reads a dozen real-time feeds at once, prices every opportunity with a stack of competing models, and treats every strategy as an experiment to be proven in simulation before it risks a cent. Hundreds of strategy variants trade against paper twins on live data, and only the ones the ledger vindicates graduate to real money.
The idea
Small edges, everywhere, gone in seconds
Prediction markets misprice constantly, especially in their quieter corners. The edges are real but tiny, crowded, and fleeting. Capturing them is an engineering problem.
The edge
Faster, broader, more disciplined
The opportunities are scattered across assets and venues: a crypto market slow to reprice after a Binance move, a set of outcomes that sum to less than a dollar, a weather line no bot is watching. Each one is small and short-lived.
- Latency arbitrage: react to a price move before the market's odds catch up
- Market making and multi-outcome arbitrage: buy every side when they sum under a dollar
- Sentiment and structural arbitrage: price quiet markets from first principles
- The catch: each edge is tiny, contested, and gone in seconds
The method
Prove it in paper before it risks a dollar
Every strategy is an experiment. It runs as a named variant against a paper twin on live data, judged by criteria written before launch, and only reaches real money once the evidence holds up.
- Hundreds of strategy variants, each with its own ledger and paper twin
- A tick-level dataset recorded for honest backtests and model training
- A stack of competing fair-value models, plus a language model where it helps
- Real money only after the paper record earns it
The engine
The life of a trade
Six things happen between a market tick and a settled, recorded position, many times a second, across every market at once.
The feeds never sleep
A websocket per crypto asset streams spot ticks from Binance, the prediction-market order book is polled every couple of seconds, and Kalshi, sharp sportsbook odds, weather ensembles, and news all flow in at once. One process per domain is the single source of truth for market state, and it feeds everything downstream.
Every model weighs in at once
For each tick, a stack of independent fair-value models runs in parallel: a momentum-latency curve, a mean-reversion table, an order-flow microprice, an options-style estimate from realized volatility, and the market's own de-vigged implied odds. Nothing is filtered yet; the system just records what every model thinks, on one line.
A regime gate blocks the chop
Before any new position, a statistical regime detector asks whether the market is trending or just chopping sideways, and suppresses entries that would get whipsawed. It fails open by design, so a stalled detector can never freeze the fleet or block an exit.
Each variant makes its own call
Hundreds of strategy variants read the same signal stream, and each applies its own gates: minimum edge, momentum band, timing window, trend filters, direction locks, entry price. A global risk manager sits over all of them, sizing positions with fractional-Kelly, drawdown caps, and a loss cooldown across every market at once.
Paper and live, executed the same way
Orders run through one execution path with identical guards. Paper fills are simulated by walking the real order book with slippage and phantom-liquidity caps, so a simulated win is an honest one. Live orders go to the exchange as real trades, with a cumulative fill cap that pauses a strategy the moment it misbehaves.
Settle, record, reconcile
Every position settles from the market's own resolution feed, paper and live identically. Each fill writes to a trade ledger and to a second, independent ledger computed from first principles, so a bug can't inflate the record. Live winners redeem on-chain automatically, and every money number carries a content hash.
Under the hood
The parts worth a closer look
A dataset worth more than any single trade
Every tick, order-book snapshot, and signal is recorded at one-second granularity into typed, compressed, queryable tables: eight schemas, over 150 columns, streamed as JSONL and rolled into a columnar warehouse. It's ground truth, the fuel for honest backtests and for training the models that price the next trade. The data is an asset in its own right.
Where the language model earns its place
AI isn't bolted on for show. A model reads breaking news and event markets in plain language, and a second pass detects logical implications between markets, where one market's outcome constrains another's. It runs on a strict budget, caches its answers, and never moves money on its own.
Hundreds of experiments, run like science
Every strategy is a pre-registered experiment: a metric, a window, an n-threshold, and kill criteria, all written before it launches, with no moving the goalposts afterward. Each live strategy has a same-config paper twin running beside it, so its edge is measured against reality, not hope. A name is a contract with its data.
Breadth most desks never touch
One engine trades four crypto pairs and settles six sports, weather, and event markets, across Polymarket, Kalshi, and cross-exchange venues, from eleven live data feeds. A live real-money book runs the proven strategies, while a set of research subsystems scans the other venues in simulation, hunting the next edge.
The payoff
From paper to profit
The point of all that simulation was to earn the right to trade real money. Millions of paper trades, across months of shadow trading on live data, narrowed hundreds of ideas down to the few that actually held an edge. Those graduated to a live, real-money book, and once optimized, they returned a highly significant ROI on every dollar traded.
Every figure here traces to the platform's own ledgers and content-hashed reporting tools, never an estimate or a projection. Which strategies stay live is a decision the data makes.
Built to be operated
The unglamorous parts that keep it honest
- The ledger is the truth; the comments lie. A founding rule of the system: trust only code, ledgers, and on-chain state, never a name or a note. Money figures are quoted only from canonical tools, each stamped with a content hash, so any number can be reproduced exactly.
- A config change is a new name. Nothing is edited in place on a live strategy. Change a single knob and it becomes a new variant with a fresh ledger, because the name is a contract with its data. It's how results stay comparable across months of trading.
- Built to fail stopped, not fail trading. Live strategies are started by hand and never set to auto-restart, a fill cap pauses any that misbehaves, and a daily-loss circuit breaker can halt the entire real-money fleet at once. Real money moves only on an explicit human go.
- Every incident becomes a rule. A lock that hung silently for eight days; a config toggle that quietly zeroed the fleet for two weeks. Each failure is written down and turned into a guardrail, so the same money is never lost the same way twice.
Stack
Serious tools, sensibly chosen
Have something this complex to build?
Real-time data across a dozen feeds, machine learning in the loop, money on the line, and a standard that every result be reproducible: that's the kind of system we like most. Tell us what you want built, and within 48 business hours you'll get a written plan and a fixed quote, no sales call.
Get a build quoteDetails anonymized. Exchanges, venues, and data providers referenced above are integrations, not clients.