First-hand · verified against the real thing
How I built a quantitative research lab in Python — one person, no Bloomberg terminal
In one line: QuantLab is a research framework for systematic trading strategies, built as one script per experiment with a shared walk-forward engine and a journal that forces honesty. The architecture, from the person who built it.
QuantLab started with an uncomfortable realization: it is trivially easy to write a backtest that prints beautiful numbers and means nothing. So instead of hunting strategies, the project was built backwards — the machinery of discipline first, the strategy hunt second. This is how the lab is actually put together. It is a first-hand project report, not a tutorial paraphrase.
One script per experiment, forever
The core convention: every research question gets its own numbered script — quantlab_r001.py through quantlab_r095.py for the crypto arc, forex_f001.py through forex_f009.py for forex. One script, one falsifiable question, one answer written to a journal. Ninety-five scripts sounds chaotic until you see what it buys: any experiment from months ago can be re-run byte-for-byte, and nothing was ever edited in place to make a bad result look better. Gaps in the numbering are honest too — abandoned runs stay abandoned.
The shared engine
Common work lives in one place: a shared backtest engine (scripts/ql_engine.py) that handles feature engineering, signal masking and the walk-forward simulation loop, so every experiment runs its data through the same pipe. That is where the discipline lives — the engine splits time so that training only ever sees the past, and the experiment scripts cannot quietly peek at the future because they never hold it. Data flows through parquet caches (exchange OHLCV for crypto, 1H/1D sources for forex), because a lab that re-downloads its data every run is a lab that stops experimenting.
The journal is the product
Every run writes its verdict to quantlab_output/ — a final report, a journal entry, CSVs of trades, charts — and one machine-readable CSV indexes them all. The vocabulary is decision-forcing: a run ends as PROMOTE, WATCHLIST, REJECT, RETRACTED or OVERFIT. There is no “interesting”. The journal exists because memory is where backtesting goes to die; the moment you let yourself remember results instead of logging them, the flattering ones get remembered and the rest fade.
What the stack actually is
Deliberately boring: Python, pandas, NumPy, scikit-learn for the condition filters, matplotlib for the charts, SQLite and Telegram alerts for the paper-trading bot. No distributed anything, no proprietary data — exchange APIs and free sources, gated by the project's rule that an edge must survive realistic costs or it is not an edge. The whole lab runs on one machine. The barrier to doing this work was never the tooling; it was the honesty layer, which no library ships.
What came out of it — including the failures that turned out to be the most valuable findings — is in the lessons from ~140 documented experiments, and the single most instructive bug is its own story: the day the lab caught its own lookahead bias.
Research note: QuantLab experiments are presented for educational and research purposes. Historical backtests and simulations do not guarantee future results and should not be interpreted as investment advice.
Sources
Next