How TradingPal Backtests: The Three Engines Behind Every Number

One site, three different backtests

It would be simpler to claim TradingPal has “a backtest.” It has three, because it measures three different kinds of thing. A trendline and a chart pattern aren't the same object, and neither is a whole portfolio traded over decades — so each gets a test built for what it actually is.

The first engine tests trendlines (the automatic support and resistance lines drawn on every chart): when price comes back to a line, does it hold, reject, or break? The second tests chart patterns (wedges, pennants, triangles): when a pattern breaks out, what happens next? The third — Autopilot — tests the whole thing as one portfolio: take those signals, size them, cap them, pay the frictions, and track the account over 25 years.

What ties them together is discipline, not mechanics. All three replay history one bar at a time with no peeking at the future, count every trade including the losers, and — most importantly — get validated on data they were never tuned on. That last rule is the one that separates a real edge from a story fit to a chart, and it's worth its own explainer.

The rules all three obey

Before the differences, the non-negotiables. Every engine here follows the same four disciplines that make a backtest honest — the same ones covered in depth in our plain-English backtesting guide:

• No look-ahead: standing on any given day, the test may only use prices that already existed. It never “buys the low” or knows how the week ends.
• Count everything: every trade the rule would have taken is logged — winners and losers. Nothing embarrassing gets quietly deleted.
• Frozen exits: every simulated trade carries a safety exit (a “stop-loss”) set in advance and actually obeyed. There is no holding and hoping in the data.
• Out-of-sample validation: a rule earns its keep on one slice of history, then has to prove itself on years and symbols it was never tuned on. Rules that only shine on the data they were built from get thrown out.

Engine 1: how we backtest trendlines

The lines TradingPal draws are automatic support and resistance (the price levels buyers and sellers have defended before). A line's track record answers one question: historically, when price returned to a line like this, what did it do? We replay every prior time price reached the line and count the outcomes — did it hold and bounce, did it reject and turn, or did it break clean through?

The trade model behind those numbers is deliberately literal. The entry is the line itself — the price you could have rested an order at in advance — a buy where price dips into support or a sell where it rips into resistance. The safety exit is a close beyond the line: a wick poking through doesn't count, but a full daily close on the wrong side ends the trade. That's the “worst drawdown” and “average result” you see on a line, measured, not guessed.

The part that keeps this honest is which lines we choose to trust. A drawing engine can always find more lines; the filters that decide which are worth showing are tuned on one set of history, then confirmed on held-out symbols the tuning never saw. Gates that looked great in-sample but fell apart out-of-sample get cut — the config files literally carry notes like “died out-of-sample, never a gate.” What survives is the small set of lines with evidence behind them.

Engine 2: how we backtest chart patterns

Patterns — wedges, pennants, triangles — are tested as breakout trades. The production detector runs once over a stock's full history, and every pattern it ever confirmed becomes a trade event. From each breakout, the test walks forward bar by bar and scores the result.

The mechanics: entry fills at the confirmed breakout line — the level you could have set an order at ahead of time, or the next day's open if the stock gapped straight past it, never a price you couldn't have gotten. The target comes from the pattern's own height (the “measured move”). The stop is frozen at entry and only triggers on a close beyond it, so a scary wick doesn't shake you out — but a real loss can run past 1R when a bar closes deep against the trade. On upward breakouts the test keeps riding past the target while price holds above its 10-day average, because that ride tested better than selling on the dot.

Then the anti-curve-fit step, at scale. The entry gates and stop models don't get to pick themselves on the same data they're graded on. We run the validation in the cloud — hundreds of tickers, each in its own container — scoring every candidate rule as a pre-registered slice against a single out-of-sample ledger it couldn't have been fit to. A gate has to earn its place on prices it never trained on, or it doesn't ship.

One honesty note we carry into every pattern report: the detector's breakout confirmation looks a few bars past the breakout to rule out instant fakeouts, so these numbers measure the run rate of confirmed breakouts — not a signal you could have acted on at the very first tick. It's a real edge, described precisely rather than flattered.

Engine 3: how we backtest Autopilot (the portfolio)

The first two engines answer “does this signal work?” — assuming you could take every one with unlimited money. Real accounts don't work that way. Autopilot is the third engine, and it's the one behind the aggregate equity curve on our about page: it takes the same signals and runs them as one actual portfolio, with real-world limits switched on.

It works in two passes. First it collects every historical trade the real engine would have produced across the universe. Then it walks the calendar day by day: on each day it ranks that day's candidates using only trades that had already finished by then (a “walk-forward” score with no hindsight), then applies the live rules greedily — a cap on how many positions can be open, position sizing of a flat 1% of the account's current equity, and cash that only frees up when a trade actually closes. Compounding, capacity, and timing all come out in the wash, the way they would in a real account.

We publish this one with its limitations printed, because the details matter. The baseline enters at the model's first poke of the line — an optimistic upper bound; live entries land a few bars later under the entry guard, and a separate friction run haircuts every fill and turns some takes into small scratch losses to show the pessimistic side. Between entry and exit a position is marked at its entry value rather than day-by-day, so the true peak-to-trough dip runs somewhat deeper than the settled curve shows. It's a rigorous estimate of what the configured strategy would have done — stated as an estimate, not a promise.

The output, refreshed nightly

None of this is a framed report from one good year. The pattern and trendline engines re-run after every nightly scan across 500+ stocks, so the numbers on the site are the latest test, not a screenshot. This is the live pattern scoreboard — each pattern's win rate, average return in R, and the trade count behind it — straight from last night's run.

What all three can and can't promise

Out-of-sample validation is the strongest test we can run, but it's still run on the past — and the past isn't a promise. A rule that held up across decades and unseen symbols has cleared a high bar; it has not seen next year, because no backtest can. That's exactly why we re-test nightly and grow the strategy instead of resting on an old number.

Real fills also differ from simulated ones by a little: prices move fast at a breakout, and a live order can land a few cents off the tested price — which is why Autopilot ships a friction scenario alongside the clean one. Held together honestly, the three engines tell you the odds so far, measured three different careful ways. They don't tell you the future. They make sure every number standing next to a chart was counted, not remembered.

How TradingPal Backtests: FAQ

Keep learning