Backtesting is how you find out whether a trading idea has ever worked, before you fund it. It won't tell you whether a strategy will work — nothing will — but it filters out a large share of ideas that sound good and have never made money, and it forces you to state your rules precisely enough to be tested at all. A sloppy backtest tells you what you want to hear; a rigorous one tells you what you need to know. This guide covers both: the methods, the metrics, and the specific mistakes that make backtest results look far better than they are.
What Is Backtesting in Trading?
Backtesting means running your trading strategy against historical price data to see how it would have performed. You define your rules — entry signals, exit conditions, position sizing — then simulate executing those rules as if you were trading in the past, either manually or through a backtesting engine.
The output is an equity curve and a set of performance statistics. Done properly, it converts "I think this works" into "across 1,200 trades over eight years, this strategy had a Sharpe of 1.3, an 18% maximum drawdown and a 1.6 profit factor" — a statement you can make a decision on. Or it reveals that the strategy lost money in four of those eight years, which is just as useful. A strategy with a 35% win rate and negative expectancy is worth discovering in a spreadsheet rather than in a funded account.
The value isn't the headline return figure. A backtest shows you the drawdowns, losing streaks and dead periods you would have had to sit through, and where the strategy struggled — whether it got chopped up in low-volatility ranges, or gave back a year of gains in a single quarter. Those patterns tell you whether there's a genuine edge or the strategy was riding one favorable regime. Drawdown tolerance in particular is usually imagined rather than tested: Dalbar's long-running investor-behavior studies find that average investors underperform their own holdings largely because they sell during drawdowns and buy back after recoveries. Knowing the drawdown profile in advance lets you size positions so the worst case stays inside what you'd actually sit through, not the tolerance you imagine you have.
Forward testing — paper trading in live conditions — validates a backtest but takes months. Backtesting compresses years of market history into hours of analysis. Most traders use both: backtest to filter ideas out, forward test to confirm the survivors.
Key Metrics to Track When Backtesting
Raw profit isn't enough. A strategy that made $50,000 with a 60% maximum drawdown would have shaken out most traders long before the recovery arrived, and a 20% annual return means something entirely different at a 12% drawdown than at a 60% one. These are the numbers worth reading first.
| Metric | What It Tells You | Rough Benchmark |
|---|---|---|
| Win Rate | Percentage of profitable trades | 40–60%, but meaningless on its own |
| Profit Factor | Gross profit ÷ gross loss | Above 1.5 after costs is a common screen; below 1.0 is a net loser |
| Max Drawdown | Largest peak-to-trough decline | Under 20–25% is what most retail traders tolerate |
| Sharpe Ratio | Annualized return per unit of volatility | Above 1.0 is respectable; above 3.0 deserves suspicion |
| Sortino / Calmar | Return vs downside volatility / vs max drawdown | More informative than Sharpe for skewed strategies |
| Average R:R | Average reward per unit of risk | Above 1.5 for most strategies |
Treat that last column as convention, not standard. There is no regulatory or academic threshold that makes a profit factor of 1.5 "viable" — these are numbers traders have converged on because strategies below them tend to break under real costs. Your own thresholds should depend on your trade frequency, your cost structure and how much drawdown you can actually sit through. If one number deserves priority, it's maximum drawdown: it defines the worst pain you'd have to endure to collect the strategy's returns, and it's the number most traders' discipline actually breaks on.
One caveat on Sharpe specifically: it assumes returns are roughly symmetrical. Strategies that sell options, fade volatility or scalp mean reversion produce many small wins and rare large losses, which flatters Sharpe badly. Calculate Sortino and Calmar alongside it before you trust a high number — and treat a Sharpe below 0.5 as a sign you're not being paid for the volatility you're enduring, whatever the total return says.
A 35% win rate can be profitable with a 3:1 reward-to-risk ratio. A 70% win rate can be unprofitable if your losers are five times your winners. Win rate and payoff size only mean something as a pair — look at the full picture.
Three Methods to Backtest Your Trading Strategy
There is no single right way to backtest. Your choice depends on your technical skills, the complexity of your strategy, and how much time you're willing to spend.
1. Manual Backtesting (Replay Method)
Manual backtesting means moving through historical charts bar by bar and recording what you would have done at each moment. Replay tools hide future price action so you can't cheat.
The process:
- Load historical data and scroll back to your start date
- Step forward one candle at a time
- When your entry conditions appear, log the trade in a spreadsheet
- Record entry price, stop loss, target and eventual outcome
- Move to the next setup
This is slow — expect two to four hours to test one strategy across one year of daily data. But it teaches you things automated tests hide. You internalize how your strategy behaves in trends, ranges, volatility spikes and choppy conditions, and you find out how many setups actually appear rather than how many you imagined.
Two things to know about replay tools before you start. TradingView's Bar Replay is available on the free plan but restricted to daily and higher timeframes; replaying intraday charts requires a paid tier, and how far back the minute-level replay data goes scales with the tier. Schwab's thinkorswim OnDemand replays full historical sessions including intraday, which makes it the better free option if you're testing day-trading setups and already have an account there — note it lives in the desktop version of the platform, not the web app.
Manual backtesting works best for discretionary strategies where context matters. If your entries involve judgments like "this looks like a strong trend" or "volume seems climactic," automation won't capture that nuance anyway.
2. Platform-Based Backtesting
TradingView. The Strategy Tester runs Pine Script strategies and returns a trade list, equity curve and performance summary in seconds. The community library of shared scripts means you can often start from something close to your idea rather than from scratch. Its limits show at the edges: Pine Script isn't designed for portfolio-level logic across many symbols, and advanced traders eventually bump into the language's constraints.
The limitation to plan around is data depth. On the free plan, backtests are capped at roughly 5,000 bars on most timeframes. On a daily chart that's about two decades — fine. On a 5-minute chart it's a couple of weeks, which is nowhere near a statistically meaningful sample. Deep Backtesting, which runs against a symbol's full history up to two million bars and one million trades, requires Premium or higher. So does Bar Magnifier, which pulls lower-timeframe data to model what actually happened inside each candle. If you intend to test intraday strategies over multiple years, budget for that tier or use a different tool — check TradingView's pricing page for current rates, since the tiers change.
MetaTrader 5. If you're setting up now, start on MT5 rather than MT4. MetaQuotes stopped selling MT4 licences to new brokers and ended development of the platform, MT5 has overtaken it in retail CFD market share, and brokers are actively retiring MT4 servers — OANDA's Japanese arm, for instance, has set a full MT4 shutdown for November 2026, citing security standards the unmaintained platform can no longer meet. Traders with a working MT4 setup and MT4-only Expert Advisors have no urgent reason to migrate mid-strategy, but building something new on MT4 means building on a platform with a published end date.
MT5's Strategy Tester is genuinely strong for forex: multi-currency testing, real tick data from brokers that supply it, genetic optimization, and a direct path from backtest to live deployment. The cost is MQL5, which has a steeper learning curve than Pine Script.
Broker platforms. Interactive Brokers, Schwab thinkorswim and cTrader all include strategy testing. thinkorswim is worth singling out because it ships three distinct tools: thinkBack for options, OnDemand for replay, and Custom Strategies built in thinkScript. thinkBack is one of the very few options backtesters you can reach without buying a separate data subscription. The general advantage of broker-native testing is that you're using the data and execution conditions you'll actually trade.
AmiBroker. A desktop stalwart of systematic equity traders for over two decades. Its AFL scripting language takes learning, and the interface looks dated, but the engine is extremely fast at portfolio-level backtesting and scanning across large stock universes, with walk-forward optimization and Monte Carlo analysis built in. Licences are one-time rather than subscription — $299 for the Standard edition and $379 for Professional, with two years of upgrades included — though you'll pay separately for a data feed.
SimpleMarkets. Full disclosure: this is our platform. It lets you define your rules and run a backtest without writing code, on real crypto, stock and forex data, and returns the trade list and metrics covered above.
3. Code-Based Backtesting (Python Libraries and Cloud Platforms)
Writing your own backtest gives you complete control over position sizing, custom indicators and portfolio-level logic. The realistic options:
- backtesting.py — lightweight, well documented, minimal boilerplate. The sensible first library.
- vectorbt — vectorized rather than event-driven, which makes it extremely fast for sweeping thousands of parameter combinations at once. The open-source edition is fair-code licensed (Apache 2.0 with Commons Clause); the actively developed successor, VectorBT PRO, is proprietary and paid.
- backtrader — still the most-referenced library in tutorials, and worth reading for its enormous archive of examples. But it is effectively unmaintained: no significant release in years, and known friction on recent Python versions. Fine for learning, poor as a foundation for anything you plan to run for years.
- NautilusTrader — event-driven with a Rust core, built so that backtest and live execution use the same code path. Steeper entry, but the right answer if execution fidelity is the point.
QuantConnect sits between a library and a platform, and it's the option most beginner guides leave out. Its free tier includes cloud backtesting across equities, options, futures, forex and crypto with historical data included, so you skip the data-sourcing problem entirely. The underlying engine, LEAN, is open source, meaning you can inspect exactly how fills and costs are modelled and run the same strategy locally if you outgrow the cloud. Its point-in-time universe data — which includes delisted securities — also addresses the survivorship bias problem covered below, which is otherwise expensive to solve. Live deployment and heavier compute are paid tiers.
The barrier to all of this is programming knowledge. AI-assisted coding has lowered it considerably — you can describe a strategy in plain English and get working Python back. But a strategy you can't read is a strategy you can't debug, and backtest bugs are usually silent. They don't throw errors; they produce plausible-looking numbers that happen to be wrong.
Which Method Should You Choose?
| Your Situation | Best Fit |
|---|---|
| New trader learning to read price action | Manual replay — TradingView Bar Replay or thinkorswim OnDemand |
| Rule-based strategy, limited coding skills | TradingView Pine Script or the MT5 Strategy Tester |
| Intraday strategy tested over several years | TradingView Premium (Deep Backtesting) or MT5 with real tick data |
| Scanning or rotating large stock universes | AmiBroker or Python |
| Custom logic or portfolio-level rules | Python (backtesting.py, vectorbt) or QuantConnect |
| Options strategies | thinkBack, OptionStack, or Python on a paid options dataset |
Start simpler than you think you need. Manual backtesting teaches you things automated tests hide, and the fastest way to waste a month is to build tooling for a strategy you haven't yet confirmed produces enough setups to be worth trading.
Step-by-Step: How to Backtest a Trading Strategy
Step 1: Define Your Strategy Rules Clearly
Ambiguity kills backtests. "Buy when the trend is strong" isn't a rule. "Buy when price closes above the 50 EMA and RSI(14) crosses above 50" is a rule. If any part of the strategy requires subjective judgment, you don't yet have a backtestable strategy — you have a discretionary one, which is what manual replay is for.
Document all five of these before you start:
- Entry conditions — exactly what must happen, with AND/OR logic stated explicitly
- Exit conditions — take-profit levels, stop placement, trailing rules, time-based exits
- Position sizing — fixed dollar amount, percentage of account, or volatility-adjusted (ATR-based)
- Trade management — do you scale in, scale out, move stops to breakeven
- Portfolio-level risk limits — maximum concurrent positions, maximum exposure to one sector or asset, and a drawdown level at which you stop and reassess
Write it down. If you can't explain the strategy in writing, you can't test it reliably, and you certainly can't tell later whether a disappointing live result came from the strategy or from your improvisation.
Step 2: Choose Your Data Sample
More data isn't automatically better — the market regime of 2008 may tell you little about today — but too little data gives you statistically meaningless results.
- Intraday strategies (5-minute to 1-hour): 1–2 years minimum
- Swing strategies (daily timeframe): 3–5 years minimum
- Position strategies (weekly): 5–10 years minimum
Whatever the span, make sure it contains more than one kind of market. A long-only strategy tested exclusively through a bull run hasn't been tested at all — include bear phases, crashes and extended sideways chop, or you're measuring the market rather than the strategy.
Check that your platform tier can actually supply this before you start. This is where a lot of beginner backtests quietly fail: a 5-minute strategy tested on a free TradingView account is working from a few weeks of data, no matter what the requirement above says.
Where the data comes from matters as much as how much of it there is. Yahoo Finance offers free daily bars for stocks and ETFs, with inconsistent quality and no intraday depth. Alpha Vantage and Polygon.io sell API access with intraday data at various price points. For crypto, use the historical data published by the exchange you'll actually trade on — Binance and Coinbase both provide it. For survivorship-bias-free equity history, Norgate Data and CSI Data are the standard paid retail options, and CRSP is the academic benchmark. The general rule: free data is fine for learning and rough validation; if real capital will ride on the results, paid data is worth the cost.
You also need enough trades. A strategy that triggers eight times in five years tells you almost nothing. Around 100 trades is the usual rule of thumb for drawing tentative conclusions — treat it as a floor rather than a target, and remember that 100 trades from one market regime is weaker evidence than 100 trades spread across several.
Finally, split the sample before you look at it. Reserve roughly the last 30% of your data and don't touch it. That reserved block is the only honest test you'll get of whether the parameters you settle on generalize, and it's worthless if you peek at it during development.
Step 3: Execute the Backtest
Set your commission and slippage assumptions before you look at any results. Defaults on most platforms assume zero of both, and once you've seen an attractive equity curve it becomes very hard to add costs honestly.
Then walk through the trades rather than reading the summary. Open the trade list and check that individual entries and exits match what you intended. Coding errors are the norm, not the exception, and they rarely announce themselves.
Run the same test on correlated assets in the same class. A strategy that works on BTC should do something reasonable on ETH. If it only works on one symbol, you've probably fitted to that symbol's history rather than found a behaviour.
If you want worked examples, the publicly documented, backtested strategies in the SimpleMarkets library show full rules, test windows, cost assumptions and trade lists for every entry.
Step 4: Analyze Results and Identify Issues
Your backtest returned 150% annually. Before you act on it, check for these:
- Overfitting — does the strategy have fifteen parameters tuned to perfection? It probably won't survive contact with new data.
- Look-ahead bias — did an entry rule use information that wasn't available at that moment? Repainting indicators are the classic culprit.
- Unrealistic fills — did you assume entry at exactly the price you wanted? See the intrabar problem below, which is subtler and more damaging than ordinary slippage.
- Concentrated results — did 80% of the profit come from three trades? That's a sample of three, not an edge.
Look at the path as well as the destination. Two strategies can post the same total return with completely different equity curves, and a steady slope with shallow pullbacks is far more tradeable than a jagged line of deep drawdowns and sharp recoveries — same headline number, very different odds that you'd have stuck with it.
Then test robustness. Nudge each parameter slightly and re-run. If performance collapses when you change a moving average from 20 to 21 periods, you haven't found an edge — you've found a coincidence that happens to sit at 20.
Whatever survives this stage is a hypothesis, not a conclusion. The next step is forward testing, and the thing that makes forward testing useful is recording live results in enough detail to compare them against what the backtest predicted — same metrics, same trade-by-trade granularity. A trading journal, a broker statement export, or a portfolio dashboard like Kubera, CoinStats or SimpleMarkets can all do this; what matters is that you're tracking the same numbers on both sides so you can see divergence early rather than after six months of drift.
Common Backtesting Mistakes to Avoid
Overfitting and Optimization Bias
You tested 500 parameter combinations and one of them returns 300% annually. That isn't a discovery — it's the expected outcome of testing 500 combinations against noise. Some of them will look excellent by chance. A useful heuristic: if your strategy has more free parameters than you can count on one hand, you're probably overfitting, and a simple strategy that behaves reasonably across several markets is almost always more robust than a complex one optimized for a single dataset.
The standard fix is out-of-sample testing: optimize on the first block of data, then test on the reserved block without changing anything. Walk-forward analysis extends this — optimize on period 1, test on period 2, then optimize on periods 1–2, test on period 3, and so on. It's harder to game than a single split because the strategy has to prove itself across multiple non-overlapping test windows, and the combined out-of-sample record simulates how the strategy would have performed if you'd updated it as you went.
What most guides miss is that out-of-sample testing alone doesn't fully solve this. If you run 500 variants and then test the best one out-of-sample, roughly one in twenty will pass by luck at conventional significance levels. The number of configurations you tried is itself information: the more you tested, the higher the bar the winner needs to clear. Track how many variants you ran, and treat a marginal out-of-sample result from a large search as no result at all.
Look-Ahead Bias
Look-ahead bias means the simulation used information that wasn't available at the moment of the trade. The classic example is making a decision at a bar's open using that same bar's close; repainting indicators, which redraw their past values as new data arrives, are the other frequent culprit. It's surprisingly easy to introduce accidentally, especially in spreadsheet-based tests or custom code where the entire price array is accessible at every step.
The fix is structural rather than a matter of care: use an engine that processes data strictly in sequence, or if you're writing your own, make sure the strategy object can only see data up to and including the current bar — never future bars. When a result looks too clean, audit for this first.
Ignoring Transaction Costs and Slippage
A scalping strategy with 200 trades per month looks very different once you include:
- Commission — even $0.50 per trade compounds fast at that frequency
- Spread — the bid-ask gap is a fee you pay on every round trip
- Slippage — market orders fill worse than expected precisely when volatility is highest
Build conservative assumptions in from the start. Add slippage to both entry and exit, use your actual commission schedule rather than a headline rate, and check your broker's typical spread for the instrument rather than the advertised minimum. For liquid large-cap stocks, one to two cents per share of slippage is a reasonable baseline; for small caps and thin crypto pairs it can be many times that. If the strategy's edge doesn't survive realistic cost assumptions, it doesn't have a real edge — this is what kills most high-frequency retail ideas.
Trusting Intrabar Fills
This is the single most common source of fake backtest profit, and most beginners never encounter an explanation of it.
A candle records four prices: open, high, low and close. It does not record the order in which the high and the low occurred. When your stop loss and your take-profit both sit inside the range of a single bar, the backtest engine has to guess which one you hit first — and depending on the engine's assumption, the same bar can be recorded as a winner or a loser.
Strategies with tight stops on higher-timeframe charts are systematically flattered by this. The fix is to feed the engine lower-timeframe data so it can see what actually happened inside each bar. On TradingView that's the Bar Magnifier feature, which is Premium-only. In Python you do it by running the backtest on finer-grained data than your signal timeframe. If you can do neither, at minimum re-run the strategy under the pessimistic assumption — stop always hit first — and see whether the edge survives.
Survivorship Bias in Your Data
Testing a stock strategy on the current S&P 500 components ignores every company that was in the index and failed out of it. You're only seeing the survivors.
This matters more than most traders realize. A "buy the dip" strategy tested on today's index members is tested exclusively on stocks that eventually recovered. It never encounters the ones where buying the dip meant holding through to bankruptcy. In equities this quietly adds on the order of a percentage point or more a year to backtested returns; in crypto, as covered below, it can flip the sign of the result entirely.
The solution is point-in-time data — historical index constituents including delisted securities. CRSP is the academic standard, Norgate Data is the common retail option for US equities and futures, and QuantConnect includes point-in-time universe data on its free tier, which is the cheapest way to sidestep the problem entirely if you're already working in code.
Testing Only One Market Regime
If you develop a long-only strategy and test it only through a bull market, you haven't tested the strategy — you've tested the bull market. Beyond simply widening the sample, read the results by period rather than only in aggregate: a strategy that made all of its money in one regime and bled through the others is a bet on that regime returning.
Markets cycle between trending and mean-reverting, high volatility and low, and most strategies have a native habitat. Rather than piling on filters until one system "handles" every condition — a reliable recipe for overfitting — some traders segment their backtests by regime and switch strategies or resize positions as conditions change, using classifiers like the VIX, moving-average slope or ADX. You don't have to go that far to benefit from the diagnosis: simply knowing your strategy loses money in ranges tells you what a drawdown means when one starts.
Reading One Equity Curve as Destiny
Your backtest produces exactly one sequence of trades, in exactly one order. That order was partly luck. Had three losers clustered together instead of being spread out, your maximum drawdown could have been twice as deep — same trades, same win rate, same profit factor, very different experience.
Monte Carlo analysis tests this directly. Take your list of trade results, shuffle the order a few thousand times, and look at the distribution of outcomes rather than the single realized path. What you want to know is the worst drawdown across those simulations, not the one your backtest happened to produce. If the 95th-percentile drawdown is beyond what you could sit through, the strategy is too risky for you regardless of what the headline number says.
Seeing what gets rejected is as instructive as seeing what passes: the SimpleMarkets research log publishes the strategy ideas that failed testing, with the numbers that killed them.
Beyond the Basic Backtest
Once a backtest looks promising, the next job is to try to break it. Walk-forward analysis is the first stress test: tune your parameters on one stretch of history, test them unchanged on the next, then roll the window forward and repeat. Stitched together, the out-of-sample segments show how the strategy would have performed had you been updating it as you went, and a curve-fit strategy tends to fall apart within the first few windows.
Monte Carlo resampling attacks the result from a different angle. It takes the trades your backtest produced and reshuffles their order thousands of times, mapping the range of equity curves the same trades could have drawn. The question it answers is how much of the result was sequence luck: if a modest reshuffle turns a smooth curve into an unbearable drawdown, the edge is thinner than the headline number suggests.
Finally, split the results by market regime — trending, ranging, high and low volatility — rather than reading one aggregate figure. An edge that only shows up in one kind of market isn't disqualified, but it is conditional, and you want to know what it depends on before you fund it.
Backtesting Crypto Strategies: What's Different
Most backtesting advice was written for equities and forex. Several of its assumptions break in crypto.
There are no sessions. Crypto trades continuously, so there's no open, no close and no overnight gap. A "daily candle" is a UTC convention imposed on a market that doesn't observe it, and any logic keyed to session boundaries — opening range breakouts, gap fades, end-of-day exits — is testing an artifact of how your data provider chose to bucket time.
Price differs by venue. The same pair trades at different prices on different exchanges, sometimes meaningfully so during volatility. Backtest on data from the venue you'll actually trade on. An aggregated index price will produce fills you can't reproduce.
Funding rates are a real cost. If you're testing perpetual futures, funding payments accrue every few hours and can dominate the P&L of any strategy holding positions for days. Leaving funding out of a perps backtest is the equivalent of leaving commissions out of an equities backtest, and the error runs in whichever direction hurts most — long positions in a bull market pay continuously.
Reported volume may not be real. Wash trading on smaller venues and thin order books on low-cap pairs mean the volume in your historical data doesn't necessarily represent liquidity you could have accessed. A backtest that fills 5 BTC at the printed price may be describing a trade that would have moved the market several percent.
Survivorship bias is extreme. Testing a momentum strategy on the current top 100 tokens ignores the thousands that pumped, entered top-100 lists, and went to zero. In equities survivorship bias costs you a few percentage points of return; in crypto it can invert the sign of your result.
Practically, this means your crypto backtest needs venue-specific data, an explicit funding assumption, and a delisted-token universe if you're testing anything broader than the majors. It also means the gap between backtest and live results tends to be wider than in traditional markets, so tracking actual positions across the exchanges you use — through CoinStats, Delta, SimpleMarkets or an exchange-level export — matters more here than it does elsewhere.
Frequently Asked Questions
How long does it take to backtest a trading strategy?
For platform-based backtesting with existing code, minutes. A Pine Script strategy runs in seconds once written. Manual backtesting takes two to four hours per year of daily data, depending on how many setups appear. Building a Python backtesting framework from scratch can take days, though subsequent tests then run quickly.
The real time sink is iteration. Your first backtest reveals problems, you refine the rules, retest, find new problems, and repeat. Budget weeks rather than hours for developing a strategy you'd actually fund.
Do I need a paid plan to backtest properly?
It depends on your timeframe. For daily and weekly strategies, free tools are genuinely sufficient — TradingView's free plan handles a decade of daily bars, and QuantConnect's free tier includes cloud backtesting with data across multiple asset classes. SimpleMarkets' own free plan includes 10 backtests per month on real data, no card required.
For intraday strategies, free tiers become the binding constraint. TradingView caps free backtests at around 5,000 bars, which on a 5-minute chart is a sample far too small to draw conclusions from, and both Deep Backtesting and Bar Magnifier sit behind Premium. If you're testing day-trading setups seriously, either budget for a paid tier or move to a code-based workflow where you control the data.
Do I need to know how to code?
Not necessarily. TradingView's Pine Script is lightweight and well documented, MT5's Strategy Tester runs packaged Expert Advisors without requiring you to write them, and QuantConnect ships templates and community algorithms you can adapt rather than build. AI-assisted coding has lowered the barrier further still — you can describe a strategy in plain English and get working Python back.
The caveat from earlier stands, though: a strategy you can't read is a strategy you can't debug, and backtest bugs are usually silent. Basic Python remains the single biggest unlock for flexibility, because it lets you test logic that visual builders and scripting languages can't express.
What is a good win rate for a backtested strategy?
Win rate without reward-to-risk is meaningless. A 30% win rate at 4:1 beats a 70% win rate at 0.5:1.
Most professional strategies land between 40% and 60%. Trend-following systems often sit at 35–45% with large winners offsetting frequent small losses; mean-reversion systems often sit at 55–65% with smaller individual gains and occasional severe ones.
Focus on expectancy: (win rate × average win) − (loss rate × average loss). Positive expectancy means profitability over a large enough sample, whatever the win rate looks like.
What's the difference between backtesting and paper trading?
Backtesting runs your strategy against historical data — a simulation of the past. Paper trading, or forward testing, runs the same rules against live market data in real time, without real money. The standard workflow is sequential: develop and validate in a backtest, forward test for a period to confirm the strategy behaves as expected in current conditions, then commit capital at small size.
Forward testing also catches what historical simulation can't: implementation bugs, data-feed quirks, and the behavioral difficulty of actually taking every signal your rules produce.
Can I backtest options strategies?
Yes, but it's substantially harder than backtesting stocks or futures. Options pricing depends on implied volatility, Greeks and time decay, all of which require historical data that's expensive and awkward to obtain.
The accessible entry point is thinkBack inside Schwab's thinkorswim, which lets you price historical options positions without a separate data subscription. OptionStack offers automated options backtesting with a visual strategy builder. For custom analysis, Python libraries like py_vollib handle the pricing maths, but you still need historical options chains.
That data is the real cost. ORATS runs $99 per month for individual traders and around $299 for its professional tier, with real-time data as an add-on and bulk historical archives priced separately. IVolatility's retail plans run about $60 per month for delayed data and $150 for real-time when billed annually, with bulk historical downloads priced per use; institutional datasets are quoted individually. Verify current rates directly before budgeting — options data pricing changes frequently.
Backtesting options without proper volatility data produces confidently wrong results. Bid-ask spreads on options are also far wider than on the underlying, which makes cost assumptions more consequential than in any other asset class.
Is a backtested profitable strategy guaranteed to work live?
No. A backtest shows what would have happened under historical conditions. It doesn't establish what will happen next, and how much you can trust it depends entirely on methodology — clean data, realistic costs and genuine out-of-sample validation make it a useful statistical filter; skip those and it's a persuasive fiction.
Backtests fail live for identifiable reasons: market regimes change, execution differs from assumptions, slippage exceeds estimates, or the apparent edge was statistical noise that looked significant. Strategies also decay as more traders find them.
Treat backtesting as a filter rather than a forecast. A strategy that fails in backtesting will almost certainly fail live. A strategy that succeeds in backtesting might succeed live — and forward testing followed by small-size live trading is the only way to find out.
Track what happens after the backtest. SimpleMarkets brings your crypto, stock and forex positions into one dashboard, so you can compare live results against what your backtest predicted instead of guessing at the gap. If you'd rather start from a strategy that already survived out-of-sample testing, the strategy library publishes full evidence for every entry — failures included. Get started →