Written in plain language. If you have been deep in the code and lost the thread of what you actually built and what is sellable, this is the map.
You built a platform that answers one question honestly: does this trading strategy actually work, or does it just look like it does? Most backtesting tools will happily tell you a strategy made 200% last year. This one tells you whether that number survives contact with data it was never fitted to — and it usually says no, which is the point. Around that sits the plumbing needed to run a strategy for real: exchange connections, order execution, position sizing, stop-loss enforcement, and a check that what you think you own matches what the exchange says you own.
Anyone who has tried systematic trading has had this experience:
- Build a strategy. Backtest it. It returns 180%.
- Tune the parameters. Now it returns 340%.
- Trade it with real money.
- Lose money.
The gap between step 2 and step 4 is overfitting, and it has a specific mechanism. When you try 40 parameter combinations and keep the best one, that best one looks good whether or not the strategy has any edge. You are reporting a maximum over 40 attempts as if it were a single measurement.
Almost every backtesting tool lets you do this and shows you the flattering number. This platform is built to catch it, in four ways:
| Check | What it catches |
|---|---|
| Walk-forward with a purge gap | Parameters fitted on the data being tested |
| In-sample vs out-of-sample degradation | A strategy that only works on data it has seen |
| Parameter stability | An optimiser chasing noise — the "best" settings jump around every window |
| Deflated Sharpe | How much of the result is explained by having searched a lot |
The last one is the sharpest. Give it 200 strategies with provably zero edge and keep the luckiest: a normal significance test says 99.5% significant. The deflated Sharpe says 43.7% — rejected. That is the difference between a tool that flatters you and one that tells you the truth.
Everything here is verifiable by running it. No claim in this document needs you to take anyone's word for it.
Research
- Backtesting with realistic transaction costs and slippage
- Leakage-free walk-forward validation (rolling or anchored windows)
- Overfitting diagnostics with a plain-language verdict
- Deflated Sharpe / multiple-testing correction
- Bayesian parameter optimisation
- 18 built-in strategies; adding one is a single file
Execution
- Live trading on Kraken (verified) and Coinbase (built, not yet live-tested)
- Paper trading with simulated fills, fees, slippage and spread
- Risk-based position sizing — a loss at the stop is ~2% of the account
- Stop-loss and take-profit enforced on every tick
- Drawdown circuit breaker, volatility scaling, correlation limits
- Position reconciliation against the exchange, halting on a mismatch
Interfaces
- REST + WebSocket API
- MCP server — drive the whole thing from Claude Desktop in plain English
- Self-contained HTML reports you can email to someone
- One-command demo that works offline on a clean clone
Engineering
- 730 tests, all running against the real import graph
- CI that boots the app and drives it end to end, plus a Docker build that fails if the container is unhealthy
- Apache-2.0
State these before anyone asks. Being the person who volunteers the limitations is worth more than the limitations cost.
- It does not make money. The bundled strategies do not beat buy-and-hold. The validation tooling exists to demonstrate that.
- Coinbase execution has never placed a real order. Written and unit-tested against the documented API, but unverified live.
- No UI. API, MCP and reports.
- One person, no support SLA, no SOC 2, no multi-tenancy.
- Python 3.10 only, pinned by vectorbt's numba requirement.
Not the software. It is Apache-2.0 — anyone can take it for free. That is deliberate: nobody hires an engineer they have never heard of to build their trading infrastructure. They hire one whose work they have already read.
What sells is the two years of knowing where the bodies are buried. Every bug fixed in this repository is a bug someone else is about to hit:
- Position sizes computed in dollars and consumed as base units
- "Out-of-sample" tests scored with parameters fitted on the test period
- Paper trading that could not start without live credentials
- A backtest that froze the entire server while it ran
- An encryption key that fell back to a constant printed in the source
- A stop-loss that was recorded and never checked
That list is the product. It is what a fintech team adding crypto is about to spend six months discovering, and what they will pay to skip.
| Price | What it is | |
|---|---|---|
| Audit | $2,500 | You review their trading code and write up what will break. One week. |
| Integration | $18,000 | One exchange, wired end to end. Four weeks. |
| Platform | $45,000 | Multi-exchange, validation, monitoring, CI. Ten weeks. |
| Retainer | $3,000/mo | Maintenance and on-call. |
Full terms in COMMERCIAL.md.
Fintech engineering teams, 15–80 people, adding crypto buy/sell to an existing product. They need exchange connectivity and a way to test safely, and they have no market-structure expertise or any wish to acquire it.
Find them by looking for job postings mentioning Kraken, Coinbase, CCXT or "exchange integration". A live job posting means they have already budgeted for the problem — that is the strongest buying signal available.
Who does not buy: crypto prop desks and funds. Execution is their edge; they build it in-house on purpose. That was the original target and it was wrong.
Most trading backtests are wrong, because the parameters were fitted on the same data used to evaluate them. I built a platform that detects that — it reports in-sample versus out-of-sample degradation, how much the chosen parameters move between periods, and a deflated Sharpe that corrects for how many combinations you searched. It usually tells you your strategy does not work. Around it sits the execution side: exchange connectivity, risk-based sizing, stop-loss enforcement and reconciliation. It is open source. What I sell is building the same thing for teams adding crypto to their product.
Read these, in this order:
| File | What it tells you |
|---|---|
| README.md | Quickstart, and what the thing is |
| This file | What it solves, and what is sellable |
| POSITIONING.md | Who buys, competitors, objection handling |
| COMMERCIAL.md | Prices and engagement terms |
| ARCHITECTURE.md | How the code fits together, and why |
| ROADMAP.md | Known limitations — show this to prospects |
| SECURITY.md | Key handling and threat model |
| DEMO.md | The walkthrough, annotated |
The code that matters most, if someone asks you to show them something:
| File | Why it is worth reading |
|---|---|
core/backtesting/walk_forward.py |
The validation engine. The docstring explains the leak it was built to fix. |
core/backtesting/deflated_sharpe.py |
The multiple-testing correction. |
core/trading/risk.py |
Sizing, drawdown, volatility, correlation. |
core/trading/reconciliation.py |
Why a phantom position is the dangerous case. |
core/wrappers/base.py |
The exchange contract — how you add a venue. |
tests/test_walk_forward.py |
TestNoLeakage — the regression that cannot come back. |
Commands you will actually use:
make setup # deps, secrets, market data
make demo # the full walkthrough, asserts every step
make report # walk-forward as a shareable HTML file
make mcp # MCP server for Claude Desktop
make test # 730 testsYou did not build a money printer. You built a measurement instrument that refuses to lie to you, and the engineering judgment behind it is the part that has commercial value. The code is free. The judgment is not.