I’ve recently joined the QuantJourney team as an ML & data engineer, working on the data pipelines and feature layer. In short, my focus is keeping the data and features that strategies rely on reliable and reusable — extending the engine’s metrics, and building a feature engine and feature store that behave the same way on historical (batch) and live (streaming) data, so the same features can power both trading strategies and machine-learning models.

What’s being built

QuantJourney is an open-source, Python-native backtesting engine for reproducible portfolio and order-based research, with a managed data layer and a hosted team workspace extending it. The conviction behind it is one I share: backtests are easy, defensible research is hard. So instead of stopping at “signal times returns,” the engine turns a strategy idea into an auditable research packet — signals become target weights or explicit orders, orders become simulated fills, positions and NAV reconcile to one self-financing ledger, and every assumption is on the record and reproducible.

Cumulative portfolio returns charted against a benchmark.
Every run reconstructs NAV from portfolio state and charts it against a benchmark.

What’s possible

The engine covers two complementary research modes from one contract:

  • Weight mode — portfolio research: factor portfolios, rotation models, long/cash and long/short books, risk overlays, volatility targeting and scheduled rebalancing.
  • Order mode — execution-aware research: market, limit, stop, stop-limit, trailing-stop, bracket and OCO orders, with commissions, slippage, volume participation, fills, positions, cash, NAV and trade blotters.

It ships 45 runnable example strategies (22 weight-based, 18 order-based, 5 walk-forward / optimization) spanning equities, ETFs, FX and futures, from daily rebalancing down to 1-minute bars. Parameter robustness is first-class: rolling, expanding and anchored walk-forward validation with purge/embargo, plus grid-search and Optuna optimization read as selection diagnostics rather than a single lucky backtest. Every run stays local — your strategy code, signals, accounting and reports never leave your machine.

Monthly returns heatmap produced by a QuantJourney backtest.
One repeatable run emits metrics, equity curves, drawdowns, rolling risk, heatmaps and run fingerprints.

How to run it

Install from PyPI, then run the first strategy against deterministic bundled sample data — no account, no credentials:

TerminalSample-data quick start
pip install quantjourney-bt
git clone https://github.com/datasound-projects/quantjourney-bt.git
cd quantjourney-bt
./strategy.sh example_weights_01_sma_daily --sample-data --output /tmp/qj-sample

List the full catalog with ./strategy.sh --list, and validate any strategy without a data call using --check. For real market data, set your QuantJourney API key and drop the --sample-data flag:

TerminalReal market data
export QJ_API_KEY="..."
./strategy.sh example_weights_01_sma_daily --output /tmp/qj-reports

Add the [wf] extra (pip install "quantjourney-bt[wf]") for the Optuna walk-forward examples. There’s also a set of AI Co-Pilot skill packs in skills/ — point an AI coding assistant at the relevant SKILL.md and it follows the engine’s conventions when drafting, reviewing or interpreting a strategy.

Walk-forward out-of-sample equity curve from a QuantJourney optimization run.
Walk-forward out-of-sample equity — validation is built into the workflow, not bolted on afterwards.

Why open source

Because a tool that sells itself on evidence has no business being a black box. Every step — how signals become trades, how fills and costs are modelled, how NAV is reconstructed — is open to read, audit and adapt. It’s built in the open under Apache 2.0, and every pull request gets a real reply.

How it stands out

Plenty of capable open engines exist — VectorBT, Zipline, Backtrader. What sets QuantJourney apart is that the review layer is the default, not an add-on: walk-forward, overfit statistics, crisis analysis and reproducibility come built in. Pair that with a feature store designed for both batch and streaming — open and running on your own hardware — and you’ve got a combination that isn’t sitting on a shelf anywhere yet. That’s the part that made me want in.

Where to go from here

Try it — clone the repo, run the sample above, then open an example and change the universe or the costs to see what the report tells you. Contributions are welcome through the usual fork, branch and pull-request flow, whether that’s a new example strategy, a fix or a docs improvement.

Repo: github.com/datasound-projects/quantjourney-bt · Strategies: backtester.quantjourney.cloud