A backtest Sharpe, alone, is one of the most misleading numbers in finance. Not because the math is wrong, but because of what it leaves out: how many things you tried before you found it. QuantSuite reports every result as raw SR | PSR | DSR with the trial count N visible, so the search that produced a number is priced into the number.
The quiet inflation machine behind most published backtests.
Ask 1,024 people to call ten coin flips and, on average, one calls all ten. Nobody thinks that person can predict coins — yet when a parameter sweep tries 200 strategy variants over the same history and the best one posts a beautiful Sharpe, that same selection effect is routinely sold as an edge. You didn't find the skilled strategy; you found the luckiest one, precisely because you went looking for it.
The more variants, retrains, and "one more tweak" runs you make, the higher the bar a result must clear before it means anything. A single displayed Sharpe hides all of that: a 2.0 from one pre-registered test and a 2.0 cherry-picked from 500 attempts look identical on screen — and only one of them deserves your capital. (Neither raw number, alone, tells you which — that's exactly what PSR and DSR exist to expose.)
The classic Sharpe ratio: excess return over volatility. It ignores how long the record is, how skewed or fat-tailed the returns are, and how many strategies were tried. We show it for continuity — never by itself.
The Probabilistic Sharpe Ratio: given the record's length, skew, and kurtosis, the probability that the true Sharpe is above zero. A short or lumpy record can post a high raw SR and still carry a mediocre PSR. It reads as a confidence level, not a score.
The Deflated Sharpe Ratio raises the benchmark to account for N — the number of trials it took to find this result. More trials, higher hurdle, smaller number. DSR is the figure that survived the search, and N is printed next to it so you can see the selection pressure it was deflated against.
DSR needs a trial count. Most tools don't have one, because nothing records the search. We made the recording automatic.
Each strategy variant, parameter-sweep entry, and model retrain is recorded in a trial ledger as it happens. N comes from the ledger — not from your memory, and not from your honesty in the moment of a great-looking result.
The ledger is durable. The 208 variants that didn't work stay counted when variant 209 finally shines — which is precisely when the temptation to forget them is strongest.
The recorded count is what DSR deflates against. As your search grows, the hurdle rises automatically. Nobody has to remember to be honest; the accounting does it.
Inside the terminal, Quant → Validation Center walks the gates in order on your install's own live data: the trial-ledger rows behind every DSR(N) label, then raw SR → PSR → MinTRL → DSR on a series you choose, refusals included. N is not an assumption — it is a table you can read.
Deflation fixes the statistics. Purging fixes the experiment.
Ordinary cross-validation shuffles data into train and test folds as if each observation were independent. Market data isn't: a label like "did this signal pay off over the next ten days?" computed on Monday overlaps the one computed on Tuesday. Shuffle them apart and the training folds have effectively seen the test answers — leakage that quietly inflates every score.
Training samples whose label windows overlap the test fold in time are removed. The model can't train on information that bleeds into the period it's being graded on.
A buffer of samples immediately after the test fold is dropped too, because markets remember: serial correlation lets information seep across the boundary even after purging. The embargo is the safety margin.
Scores come out lower than naive cross-validation would show. That's the pattern by now: every honest correction makes the number smaller — and more trustworthy.
Deflation fixes the statistics. Walk-forward fixes the experiment.
In-sample results fit and score a strategy on the same data — the model has effectively seen the answer key, so the numbers look great and mean little. Walk-forward testing fits on a past window, then evaluates on the next, unseen window, and rolls forward through history — mirroring how the strategy would have actually traded without foreknowledge. It's slower and the numbers come out lower. That's the point: lower and honest beats high and fictional.
A raw Sharpe of 2.14 looks like a career. PSR(0) already tempers it: given the record's length and shape, about a 71% chance the true Sharpe beats zero — decent, not thrilling. Then DSR prices in the search: this was the best of 209 recorded trials, and once that selection is accounted for, the probability the edge is real collapses to 4%.
So the verdict reads edge not established. That verdict is the product. It's the platform stopping you before the expensive step — funding a strategy whose brilliance was mostly luck.
Hand-chosen figures to show how the triplet reads. Not results from any strategy, account, or the product's own performance.
Your numbers will get smaller here. On purpose.
Every correction on this page — deflating for trials, purging leakage, embargoing the boundary — moves results in one direction: down. That's not pessimism; it's the selection tax and the leakage subsidy you were always paying, finally shown on the receipt. A platform whose numbers only ever look better than the competition's is telling you about its marketing, not your edge. Smaller and true beats bigger and fictional, because only one of those survives contact with a funded account.
Before this machinery ever judges your backtest, it judges our models — every week.
Each week the model factory retrains a challenger and walks it into the same gate: it must clear an absolute performance floor, clear the trial-corrected bar that rises with every candidate trained before it, and beat the incumbent champion — all three, or it is refused. Nearly every challenger loses. The measured record is on the homepage, read from the same registry file your install ships, and inside the terminal the Refusal Ledger lists every candidate with the reason it lost. A gate that passes everything is decoration; ours mostly says no, and we publish that instead of hiding it.
Candidates aren't quietly discarded — each gets a row: verdict, gate statistics, and the reason it lost. The screen's one-sentence summary of where the factory stands is computed server-side from the ledger itself, so the claim can never drift from the data it describes.
The Edge Report applies this exact machinery to any track record you paste in: raw SR → PSR → DSR across a ladder of N, with the breakeven N where the edge dies. The N you supply is recorded as an attestation, labeled as one in the artifact — and the verdict is signed, so a report can be handed to someone else and verified.
The best an Edge Report can say is survives at the N you attested — exactly as strong as the attestation and no stronger. There is deliberately no code path that returns "proven," because a proof of future returns is not a thing honest statistics can output.
Two authoring modes, one guarded runtime. Shipped, not a roadmap item.
A compiler for a subset of the Pine language, so indicator-style strategies you already think in can run against your own local history without rewriting them from scratch.
Full expressive strategy logic in Python against a defined API — data in, signals out — for anything the Pine subset can't express.
Before a line runs, the code is parsed and checked against a whitelist. Dangerous builtins and dynamic-attribute escape hatches are blocked, so a strategy computes signals — it doesn't touch your filesystem, network, or shell.
Whatever you write, results come back the same way: raw SR | PSR | DSR with N from the Trial Ledger — and every run you make is itself another trial the ledger counts.
If a figure can't be traced to a real provider or computation, it's labeled as missing or estimated — never quietly filled with a plausible-looking number. A blank is more honest than a fabrication.
The on-device analyst is built to say "I don't have that" instead of confabulating a value or a source. When context is thin, it defers to deterministic fallbacks rather than making something up.
Retrains and strategy variants feed a trial ledger so N is real. Deflation is only honest if the count it deflates against is honest, so we track it rather than assume N = 1.
SR, PSR, and DSR describe a historical record and the odds it's distinguishable from luck. They are diagnostics of the past, not forecasts of the future. A high DSR means the record probably wasn't luck — not that it will repeat.
If history can't be sourced from a real provider, the run refuses rather than filling the gap with synthetic ticks. A backtest over invented data is a simulation of nothing.
The backtester evaluates strategies you choose to test. Nothing it outputs is a recommendation to trade, and no statistic it computes removes the risk of loss. The decisions — and the risk — are yours.
The triplet implements peer-reviewed concepts, not house-invented scores.
Cited as the source of the statistical concepts we implement. Citation does not imply the authors' endorsement of QuantSuite.
We would rather show you a small, deflated figure — or "edge not established" — than a flattering one that falls apart the moment you fund the account. If that trade-off sounds right to you, this is your backtester.