DEV Community: Walid Koussa

Walk-forward analysis for retail traders: out-of-sample testing on a real Bitcoin example

Walid Koussa — Wed, 11 Nov 2026 02:04:28 +0000

Most backtests you see online were optimized on the same data they report. Someone tries 50 settings, keeps the best one, and shows you its equity curve. That curve is the answer to "which settings fit the past best", not "what would this strategy have earned". Walk-forward analysis is the standard way to get the second answer.

We ran one from start to finish on Bitcoin so the numbers in this guide are real. The short version: the settings that looked best in each training period averaged a Sharpe ratio of 1.44. The same settings, traded on the next six months they had never seen, averaged 0.22.

The vocabulary

Term	What it means
In-sample (IS)	The data you use to choose rules and parameters
Out-of-sample (OOS)	Data the choice never saw, used only to measure the result
Walk-forward	Repeating IS then OOS through time: optimize, trade the next block, move forward, repeat
Rolling window	The IS window keeps a fixed length and slides forward
Anchored window	The IS window always starts at the beginning and grows
Walk-forward efficiency	Out-of-sample return divided by in-sample return, both annualized

A single split (optimize on 2019 to 2023, test on 2024 to 2026) is the simplest out-of-sample test. Walk-forward does it many times, so you see how the process of choosing parameters holds up, not just one lucky or unlucky split.

Why the in-sample result is always too good

When you pick the best of N settings, you pick the one that combines whatever edge exists with the most luck. Even with no edge at all, the best of many tries looks good. On three years of daily data, the best of 100 strategies with no edge is expected to show an annualized Sharpe ratio of about 1.46. The deflated Sharpe ratio calculator works this out for any number of tries and any backtest length.

Out-of-sample data removes the luck from the selection, because the choice was made before that data existed for you. What remains is closer to what you'd have earned.

The experiment


Market	BTCUSDT spot, Binance, daily candles
Data	1 Jan 2018 to 31 Oct 2026, 3,226 days, no gaps
Strategy	Long when the fast simple moving average is above the slow one, otherwise in cash
Execution	Decided on the daily close, held from the next day; no look-ahead
Costs	0.10% per side on every change of position
Settings tried	Fast 5, 10, 20, 30, 40 × slow 50, 100, 150, 200, 250 = 25 combinations
Selection rule	Highest in-sample Sharpe ratio (annualized over 365 days)
Windows	24 months in-sample, the next 6 months out-of-sample, rolled forward every 6 months
Out-of-sample span	1 Jan 2021 to 31 Oct 2026: 12 windows, 2,130 days

Moving averages aren't special here. They're simple enough that the result can't hide behind complexity, and they're what most people try first.

What happened window by window

Out-of-sample period	Chosen (fast/slow)	IS Sharpe	OOS Sharpe	Rank out of 25, OOS
2021 H1	30 / 50	2.11	2.16	2
2021 H2	30 / 50	1.72	0.69	5
2022 H1	5 / 50	2.03	−2.52	25
2022 H2	10 / 100	1.88	−1.63	20
2023 H1	5 / 150	0.76	1.61	8
2023 H2	5 / 150	0.77	1.52	9
2024 H1	5 / 200	1.19	1.72	4
2024 H2	5 / 200	1.46	−0.01	25
2025 H1	5 / 50	1.91	0.55	12
2025 H2	40 / 50	1.58	−1.10	23
2026 H1	5 / 100	1.18	−1.05	13
2026 H2 (to 31 Oct)	5 / 100	0.66	0.75	6

Three things stand out. The chosen setting changed seven times in twelve windows, so "the best parameters" weren't stable. Twice, the in-sample winner was the worst of all 25 settings in the next six months. And the in-sample Sharpe ratio told you almost nothing about the next period: the two highest in-sample values (2.11 and 2.03) were followed by the best and the worst out-of-sample results.

The stitched out-of-sample result

Chain the twelve out-of-sample periods together and you get the equity curve you could actually have traded, switching costs included:

1 Jan 2021 to 31 Oct 2026	Walk-forward	Buy and hold	Best setting in hindsight (5/100)
Sharpe ratio	0.67	0.58	0.94
Annual return	20.8%	18.4%	34.6%
Maximum drawdown	−51.3%	−76.6%	−41.2%
Total return	+201.6%	+168.2%	+465.9%

The last column is what a single optimization over the whole period would have shown you: one setting, picked after the fact, with a Sharpe ratio of 0.94. That's the number a typical backtest screenshot reports. The tradeable version earned 20.8% a year, not 34.6%.

Walk-forward efficiency, the out-of-sample annual return divided by the average in-sample annual return of the chosen settings (82.1%), comes out at 0.25. Three quarters of the in-sample performance was selection.

Reading it honestly

The walk-forward version did a bit better than holding Bitcoin on a risk-adjusted basis, mostly because it sat in cash during part of 2022 and kept the drawdown to −51% instead of −77%. That's a real effect of trend filters in long bear markets. But it isn't proof of an edge:

Twelve windows and 23 entries in nearly six years is a small sample.
The hindsight winner, run through the deflated Sharpe ratio with 25 tries, 2,130 daily returns, skewness 0.74 and kurtosis 13.1, gives a luck Sharpe of 0.83 and a deflated Sharpe ratio of 61%. As a single test it would look 98.9% significant. Accounting for the search, you can't tell it from luck.
To pass at 95% after 25 tries at that Sharpe ratio, the same calculator says you'd need about 15 years of data.

The useful conclusion is about the process: if you'd optimized and trusted the result, you'd have expected a Sharpe near 1.4 and got about a sixth of it in the periods that followed.

Run your own walk-forward

Freeze the rules first. The indicator, the parameter grid, the costs and the selection rule (highest Sharpe, highest profit factor with a minimum number of trades…) are decided before you look at any result.
Pick window lengths that fit the strategy. Each in-sample window needs enough trades that one lucky trade doesn't decide the choice. A daily trend system needs years; an intraday one may need weeks.
Optimize on the in-sample window only, then trade the chosen setting, unchanged, on the next out-of-sample window.
Roll forward and repeat until the end of the data.
Stitch the out-of-sample results and judge only that curve, against a simple benchmark such as buy and hold.
Count every try, including grids you ran and dropped. That count is what the deflated Sharpe ratio needs.
Keep a final holdout you never touch until the very end, if you plan to iterate on the idea itself.

The code

This is the complete script we ran, in plain Python with no libraries. It reads a CSV with date and close columns (for example Binance BTCUSDT daily closes) and prints the in-sample and out-of-sample Sharpe ratio of every window, then the stitched result.

import csv, math
from datetime import date

FEE = 0.001                      # 0.10% per side
FAST = [5, 10, 20, 30, 40]
SLOW = [50, 100, 150, 200, 250]
DAYS_PER_YEAR = 365              # crypto trades every day

rows = list(csv.DictReader(open("btc_daily.csv")))
days = [date.fromisoformat(r["date"]) for r in rows]
close = [float(r["close"]) for r in rows]
ret = [0.0] + [close[i] / close[i - 1] - 1 for i in range(1, len(close))]

def sma(x, n):
    out, s = [None] * len(x), 0.0
    for i, v in enumerate(x):
        s += v - (x[i - n] if i >= n else 0)
        if i >= n - 1:
            out[i] = s / n
    return out

AVG = {n: sma(close, n) for n in FAST + SLOW}

def positions(fast, slow):
    """1 = long, 0 = flat. Decided at day i-1's close, held during day i."""
    pos = [0] * len(close)
    for i in range(1, len(close)):
        f, s = AVG[fast][i - 1], AVG[slow][i - 1]
        pos[i] = 1 if f is not None and s is not None and f > s else 0
    return pos

def daily_returns(pos, start, end, prev):
    out = []
    for i in range(start, end):
        out.append(pos[i] * ret[i] - abs(pos[i] - prev) * FEE)
        prev = pos[i]
    return out

def sharpe(r):
    mu = sum(r) / len(r)
    sd = math.sqrt(sum((x - mu) ** 2 for x in r) / (len(r) - 1))
    return mu / sd * math.sqrt(DAYS_PER_YEAR) if sd > 0 else 0.0

def first_index(d):
    return next(i for i, x in enumerate(days) if x >= d)

def month_add(d, k):
    m = d.month - 1 + k
    return date(d.year + m // 12, m % 12 + 1, 1)

POS = {(f, s): positions(f, s) for f in FAST for s in SLOW}
oos, prev = [], 0
start = date(2019, 1, 1)
while month_add(start, 24) < date(2026, 11, 1):
    a, b = first_index(start), first_index(month_add(start, 24))
    end = month_add(start, 30)
    c = first_index(end) if end < date(2026, 11, 1) else len(close)
    # pick the best setting on the in-sample window only
    best = max(POS, key=lambda k: sharpe(daily_returns(POS[k], a, b, POS[k][a - 1])))
    is_sr = sharpe(daily_returns(POS[best], a, b, POS[best][a - 1]))
    chunk = daily_returns(POS[best], b, c, prev)   # then trade it, untouched, out of sample
    prev = POS[best][c - 1]
    oos += chunk
    print(f"{days[b]} to {days[c - 1]}  best {best}  in-sample {is_sr:5.2f}  out-of-sample {sharpe(chunk):5.2f}")
    start = month_add(start, 6)

equity = 1.0
for x in oos:
    equity *= 1 + x
print(f"stitched out-of-sample: Sharpe {sharpe(oos):.2f}, total return {equity - 1:.1%}")

The prev variable carries the position from one window into the next, so a change of setting that flips the position pays its fee. Leaving that out is a common way to flatter a walk-forward.

On TradingView and MetaTrader 5

TradingView's Strategy Tester has no walk-forward mode. You can still do it by hand: optimize on a date range, then change the range to the next block and record the result without touching the inputs. Putting the test window in code, as shown in our guide to Strategy Tester settings, makes this repeatable.

MetaTrader 5's Strategy Tester has a Forward setting (1/2, 1/3, 1/4 or a custom date). It splits the chosen period in two, optimizes on the first part and checks the selected parameters on the second, always the most recent segment. That's one split rather than a full walk-forward, but it's built in and worth using on every optimization. Our guide to MT5 Strategy Tester modelling modes covers the other settings that change results.

Sources and further reading

Bailey, D. H. and López de Prado, M. (2014), "The Deflated Sharpe Ratio: Correcting for Selection Bias, Backtest Overfitting and Non-Normality", The Journal of Portfolio Management 40(5).
MetaTrader 5 Help: Strategy Tester settings: the Forward option.
Binance public market data API: the daily candles used here.

Test your own idea this way

Describe a strategy in plain English to the Backtest Lab and it runs with fees and slippage, keeps an out-of-sample period apart, and says plainly when a result could be luck. Our list of backtesting mistakes that inflate results covers what to check before any of this.

This article describes historical simulations for education. It isn't investment advice, and past or simulated results don't predict future returns. Trading involves substantial risk of loss.

Originally published on edgoro.com.

How to build a Python crypto trading bot with ccxt: data, signals, orders and a testnet

Walid Koussa — Wed, 11 Nov 2026 02:03:50 +0000

Most bot tutorials stop at "fetch the candles, place an order". The problems start right after: the bot acts on a candle that hasn't closed, sizes an order the exchange rejects, buys twice after a restart, or sells more coins than it holds because the fee was taken in BTC.

This guide builds a complete bot in one Python file of about 190 lines, using the ccxt library. It runs in a paper mode on real Binance prices without any API key, then on Binance's spot testnet. We ran every piece of it; the numbers below are its real output.

What the bot does

Trades BTC/USDT on 1-hour candles, long or flat (spot).
Enters when the 20-period EMA crosses above the 50-period EMA.
Places its stop 2 × ATR(14) below the entry close, and sizes the position so that the stop costs 1% of the USDT balance.
Exits when a candle closes below the stop or when the fast EMA falls back under the slow one.
Saves its state to a file, so a restart neither forgets an open position nor repeats an order.

It's a structure to build on, not a strategy we recommend. The backtest below shows why.

Install

pip install ccxt

We used ccxt 4.5.92 on Python 3.14. ccxt gives you one interface for more than a hundred exchanges, so the same code can move from Binance to Bybit or OKX with mostly the exchange name changed.

Candles, and the one still forming

fetch_ohlcv() returns rows of [time in ms, open, high, low, close, volume], oldest first. The last row is the candle that's still forming: its close is just the latest price. A bot that decides on it will see signals appear and vanish during the hour, the same problem as repainting in Pine Script. So the first thing the bot does is drop it:

tf_ms = ex.parse_timeframe(TIMEFRAME) * 1000
candles = ex.fetch_ohlcv(SYMBOL, TIMEFRAME, limit=SLOW * 4)
candles = [c for c in candles if c[0] + tf_ms <= ex.milliseconds()]  # drop the candle still forming

One signal function for the backtest and the bot

The indicators are written once and used by both the backtest and the live loop. If the two had separate code, you'd be testing one strategy and trading another. The EMA is seeded with a simple average and the ATR uses Wilder's smoothing, the same definitions as TradingView's ta.ema and ta.atr, so with enough history the values line up with a TradingView chart. You'll find ema(), atr() and signals() in the complete file below.

Backtest it first

The backtest decides on each closed candle and fills at the next candle's open, charging 0.10% per side. It also uses the bot's exact exit rule: the stop is checked on candle closes, as the live loop does.

On the 8,760 hourly candles from 1 November 2025 to 31 October 2026:

	Result
Trades	80
Winners	17 (21%)
Starting balance	10,000 USDT
Final balance	8,800.79 USDT (−12.0%)
BTC/USDT over the same year	109,608 → 77,582 (−29.2%)

The bot lost less than Bitcoin did, but that comparison means little: it risked 1% per trade and sat in cash most of the time. On its own terms it lost money, with a win rate of 21% and winners that didn't make up for it. That's the honest starting point for most simple trend bots on short timeframes, and exactly why you backtest before connecting anything. Our test of 2,160 crypto scalping strategies shows how much harder it gets on smaller timeframes, and the trading fee calculator shows how much of each trade the 0.10% fee takes.

Size the order, then respect the exchange's limits

The quantity comes from the stop, not from a fixed amount:

stop = bar["close"] - ATR_MULT * bar["atr"]
qty = min(cash * RISK_PCT / 100 / (bar["close"] - stop), cash * 0.99 / bar["close"])

The second term stops a tight stop from asking for more BTC than the cash can buy. Then two exchange rules apply to every order:

Precision. amount_to_precision() rounds the quantity down to the number of decimals the market accepts.
Minimums. market["limits"]["amount"]["min"] and market["limits"]["cost"]["min"] give the smallest quantity and the smallest order value. Below them the exchange rejects the order, so the bot skips the trade and logs why.

One more detail that breaks many bots: on Binance spot, the fee on a buy is usually taken in the coin you receive. Buy 0.0625 BTC and you hold slightly less, so selling 0.0625 later fails for insufficient balance. The bot reads the order's filled amount and subtracts any fee charged in BTC before it records the position.

Paper mode, then the testnet

BOT_MODE=paper (the default) uses Binance's public market data and simulates fills at the candle close, with the same fee as the backtest. No account or key is needed.

BOT_MODE=testnet sends real orders to Binance's spot testnet. Create testnet keys on the Binance spot testnet site, then export them as BINANCE_TESTNET_KEY and BINANCE_TESTNET_SECRET in your shell or a .env file you never commit. ccxt's set_sandbox_mode(True) points the exchange at the testnet. The testnet has its own order book and its own prices, which can differ a lot from the real market, so use it to test the plumbing (orders, balances, precision, errors), not the strategy.

The loop: wait, act once, survive restarts

The loop wakes 5 seconds after each candle closes.
The bot remembers the last candle it handled. After a restart or an early wake-up, it does nothing until a new candle appears.
The state file is written to a temporary file and then renamed, so a crash mid-write never leaves half a file.
Network errors (timeouts, rate limits, an exchange under load) are logged and retried next round. Anything else, such as an order rejected for a bad quantity or a wrong key, stops the bot: those don't fix themselves, and a bot that keeps retrying a broken order is how accounts get hurt.

The complete bot

import json
import os
import time
from pathlib import Path

import ccxt

SYMBOL = "BTC/USDT"
TIMEFRAME = "1h"
FAST, SLOW = 20, 50          # EMA lengths
ATR_LEN, ATR_MULT = 14, 2.0  # stop = entry - 2 x ATR(14)
RISK_PCT = 1.0               # % of the USDT balance lost if the stop is hit
FEE = 0.001                  # 0.10% per side, used by the backtest
MODE = os.environ.get("BOT_MODE", "paper")  # "paper" (no keys) or "testnet"
STATE = Path("bot_state.json")


# ---------- indicators: the same code runs in the backtest and live ----------

def ema(values, n):
    """EMA seeded with the SMA of the first n values, like TradingView's ta.ema."""
    out = [None] * len(values)
    if len(values) < n:
        return out
    e = sum(values[:n]) / n
    out[n - 1] = e
    k = 2 / (n + 1)
    for i in range(n, len(values)):
        e += k * (values[i] - e)
        out[i] = e
    return out


def atr(high, low, close, n):
    """Wilder's ATR, like TradingView's ta.atr."""
    tr = [high[0] - low[0]] + [
        max(high[i] - low[i], abs(high[i] - close[i - 1]), abs(low[i] - close[i - 1])) for i in range(1, len(close))
    ]
    out = [None] * len(close)
    if len(tr) < n:
        return out
    a = sum(tr[:n]) / n
    out[n - 1] = a
    for i in range(n, len(tr)):
        a = (a * (n - 1) + tr[i]) / n
        out[i] = a
    return out


def signals(candles):
    """candles: closed [time, open, high, low, close, volume] rows, oldest first."""
    high = [c[2] for c in candles]
    low = [c[3] for c in candles]
    close = [c[4] for c in candles]
    fast, slow, vol = ema(close, FAST), ema(close, SLOW), atr(high, low, close, ATR_LEN)
    rows = []
    for c, f, s, a in zip(candles, fast, slow, vol):
        up = f is not None and s is not None and f > s
        rows.append({"time": c[0], "open": c[1], "close": c[4], "up": up, "atr": a})
    for prev, row in zip(rows, rows[1:]):
        row["cross_up"] = row["up"] and not prev["up"]
    rows[0]["cross_up"] = False
    return rows


# ---------- backtest: decide on a closed candle, fill at the next open ----------

def backtest(candles, cash=10_000.0):
    rows = signals(candles)
    coin, stop, trades, wins, entry_cost = 0.0, None, 0, 0, 0.0
    for bar, nxt in zip(rows, rows[1:]):
        price = nxt["open"]
        if coin and (bar["close"] <= stop or not bar["up"]):
            proceeds = coin * price * (1 - FEE)
            wins += proceeds > entry_cost
            cash, coin = cash + proceeds, 0.0
        elif not coin and bar["cross_up"] and bar["atr"]:
            stop = bar["close"] - ATR_MULT * bar["atr"]
            qty = min(cash * RISK_PCT / 100 / (bar["close"] - stop), cash / (price * (1 + FEE)))
            entry_cost = qty * price * (1 + FEE)
            cash, coin, trades = cash - entry_cost, qty, trades + 1
    equity = cash + coin * rows[-1]["close"]
    return {"trades": trades, "wins": wins, "final_equity": round(equity, 2)}


# ---------- live loop ----------

def make_exchange():
    if MODE == "paper":
        return ccxt.binance({"enableRateLimit": True})  # public market data only, no keys
    ex = ccxt.binance({
        "apiKey": os.environ["BINANCE_TESTNET_KEY"],
        "secret": os.environ["BINANCE_TESTNET_SECRET"],
        "enableRateLimit": True,
    })
    ex.set_sandbox_mode(True)  # Binance spot testnet
    return ex


def load_state():
    if STATE.exists():
        return json.loads(STATE.read_text())
    return {"last_candle": None, "qty": 0.0, "stop": None, "paper_usdt": 10_000.0}


def save_state(state):
    tmp = STATE.with_suffix(".tmp")
    tmp.write_text(json.dumps(state))
    tmp.replace(STATE)  # atomic: a crash never leaves half a file


def log(msg):
    print(time.strftime("%Y-%m-%d %H:%M:%S"), msg, flush=True)


def usdt_balance(ex, state):
    quote = ex.market(SYMBOL)["quote"]
    return state["paper_usdt"] if MODE == "paper" else ex.fetch_balance()["free"].get(quote, 0.0)


def buy(ex, state, bar):
    stop = bar["close"] - ATR_MULT * bar["atr"]
    cash = usdt_balance(ex, state)
    qty = min(cash * RISK_PCT / 100 / (bar["close"] - stop), cash * 0.99 / bar["close"])
    limits = ex.market(SYMBOL)["limits"]
    try:
        qty = float(ex.amount_to_precision(SYMBOL, qty))
    except ccxt.InvalidOrder:
        qty = 0.0
    if qty <= (limits["amount"]["min"] or 0) or qty * bar["close"] < (limits["cost"]["min"] or 0):
        log(f"size {qty} is below the exchange minimum: no trade")
        return
    if MODE == "paper":
        price = bar["close"]
        state["paper_usdt"] -= qty * price * (1 + FEE)
    else:
        order = ex.create_order(SYMBOL, "market", "buy", qty)
        price = order.get("average") or bar["close"]
        base = ex.market(SYMBOL)["base"]
        fee = sum(f.get("cost") or 0 for f in order.get("fees") or [] if f.get("currency") == base)
        qty = (order.get("filled") or qty) - fee  # the buy fee is often taken in the coin you receive
    state.update(qty=qty, stop=stop)
    log(f"BUY {qty} at {price:.2f}, stop {stop:.2f}")


def sell(ex, state, bar, reason):
    qty = state["qty"]
    if MODE == "paper":
        price = bar["close"]
        state["paper_usdt"] += qty * price * (1 - FEE)
    else:
        order = ex.create_order(SYMBOL, "market", "sell", float(ex.amount_to_precision(SYMBOL, qty)))
        price = order.get("average") or bar["close"]
    state.update(qty=0.0, stop=None)
    log(f"SELL {qty} at {price:.2f} ({reason})")


def step(ex, state):
    tf_ms = ex.parse_timeframe(TIMEFRAME) * 1000
    candles = ex.fetch_ohlcv(SYMBOL, TIMEFRAME, limit=SLOW * 4)
    candles = [c for c in candles if c[0] + tf_ms <= ex.milliseconds()]  # drop the candle still forming
    bar = signals(candles)[-1]
    if bar["time"] == state["last_candle"]:
        return  # this candle was already handled (restart, or an early wake-up)
    state["last_candle"] = bar["time"]
    if state["qty"] and (bar["close"] <= state["stop"] or not bar["up"]):
        sell(ex, state, bar, "stop" if bar["close"] <= state["stop"] else "trend down")
    elif not state["qty"] and bar["cross_up"] and bar["atr"]:
        buy(ex, state, bar)
    save_state(state)


def run():
    ex = make_exchange()
    ex.load_markets()
    state = load_state()
    tf = ex.parse_timeframe(TIMEFRAME)
    log(f"{MODE} mode, {SYMBOL} {TIMEFRAME}, position {state['qty']}")
    while True:
        try:
            step(ex, state)
        except ccxt.NetworkError as e:  # timeout, rate limit, exchange busy: retry next round
            log(f"network error, will retry: {e}")
        # wake up 5 seconds after the next candle closes
        time.sleep(tf - time.time() % tf + 5)


if __name__ == "__main__":
    run()

Run it:

BOT_MODE=paper python bot.py

To run the backtest, fetch a year of candles with fetch_ohlcv() in a loop (advance since past the last candle of each batch) and pass the list to backtest().

Before real money

Restrict the API key. Enable spot trading only, never withdrawals, and limit the key to your server's IP address if the exchange allows it.
Put a real stop on the exchange. This bot checks its stop on candle closes, so a crash inside the hour isn't caught until the hour ends. For live use, also place a stop-loss order on the exchange, so the stop holds even if the bot is offline.
Run it on a server, not a laptop that sleeps, and keep the clock synchronized.
Start small, log every decision, and check the log against the exchange's trade history for the first weeks.
Add a kill switch: a daily loss limit or a file the bot checks before every order.

Next steps

Turn a TradingView idea into the same kind of code: converting Pine Script to Python.
Add holding costs if you move to perpetual futures: what funding cost on BTC, ETH and SOL.
Size leveraged positions safely: crypto futures position sizing and liquidation price.

Build your bot with Edgoro

Describe the strategy in plain English and the crypto bot builder writes a Python bot for Binance, Bybit or OKX with this structure: closed candles only, risk-based sizing, exchange limits, state saved between restarts. Test the rules first in the Backtest Lab.

This article is for education. The example strategy lost money in its backtest and isn't a recommendation. Automated trading can lose money quickly, including through software errors. Test on a testnet or paper account first and never give a bot withdrawal permissions.

Originally published on edgoro.com.

Can leverage make 10% a day? We simulated 240 setups on three years of crypto data

Walid Koussa — Tue, 10 Nov 2026 12:18:20 +0000

The pitch shows up everywhere: put a small amount on a crypto future, use enough leverage, take +10% and stop for the day. Ten percent of a small account is a small number, so it sounds modest. Leverage is supposed to do the rest.

We wanted a straight answer, so we simulated it. Every day, the same margin goes in, and the day ends at +10%, at the stop, at liquidation, or at midnight. We tried four ways of picking a direction, five leverage levels and four stop sizes, on almost three years of BTC, ETH and SOL data.

The answer is no, and the way it fails is worth understanding, because it's the same trap at every leverage level.

How the test worked


Markets	BTC, ETH and SOL perpetual futures, 1-hour candles
Main period	1 Jan 2024 to 7 Nov 2026 (1,042 days)
Check period	2020 to 2023, to see whether anything held up on other years
Each day	€100 of margin, isolated. Close at +10% net, at the stop, at liquidation or at the end of the day
Direction rules	Trend of the day, first-hour breakout, fade a 2×ATR move, and a coin flip as the control
Leverage	x5, x10, x20, x50, x100
Stop	10%, 25%, 50% or 100% of the margin
Costs	0.05% taker fee per side on the full position, 0.01% slippage, funding of 0.01% every 8 hours charged every time
Liquidation	When the price moves 1/leverage minus 0.5% against you

That's 3 markets × 4 rules × 5 leverage levels × 4 stops = 240 setups. When the stop and the +10% target both fell inside the same candle, we counted the stop first.

What happened

6 of the 240 setups made money on average. All six were the "trend of the day" rule on SOL at x5 or x10. With 240 tries, a handful of winners is roughly what luck alone produces.

The best of them made €0.66 a day per €100: +0.66% a day, not 10%. On 2020 to 2023 the same rule lost €0.88 a day. It didn't hold up.

Then we ran the version people actually imagine, where the whole account goes back in every day so the gains compound. None of the 240 accounts grew. The best one ended with €8.73 out of its starting €100.

The trap: hitting the target often isn't the same as making money

This is the part worth slowing down for.

At x20 on SOL with no stop, the trend rule hit +10% on 86% of days. That sounds like a strategy that works. Then we checked the coin flip with the same settings: it also hit +10% on 86% of days.

So the 86% had nothing to do with the rule. At x20, a normal day's movement is enough to touch +10% at some point, in either direction you pick. The problem is the other 14%. Over the test period those settings were liquidated 70 to 77 times. Each liquidation wipes out the day's whole margin, and that more than cancels all the +10% days:

trend rule: -€1,024 over the period
coin flip: -€1,535

With compounding, the account died on day one.

The maths behind it is simple. A good day pays €10. A liquidation costs the full €100, ten times as much. Around 900 winning days were more than cancelled by seventy-odd liquidations and the days that closed at a loss.

Higher leverage makes it worse, not better

Here's what the average setup did at each leverage level over 1,042 days:

Leverage	Average result per day, per €100	Days that hit +10%	Liquidations in 1,042 days	Median days before a compounding account is wiped out
x5	-€0.72	32%	0.3	295
x10	-€1.45	46%	2.5	141
x20	-€2.81	50%	13.8	81
x50	-€8.49	40%	39.9	38
x100	-€20.79	22%	107.4	18

Three things drive those numbers:

Fees are charged on the full position, not your margin. At x50, a round trip costs about 5% of your margin in fees. Half your target is gone before the price moves.
Liquidation comes very close. At x50, a move of about 1.5% against you closes the position. Crypto moves 3 to 5% on an ordinary day.
The upside is capped and the downside isn't. You stop at +10%. A loss can be the whole margin.

You can see the second point for any position with the crypto liquidation calculator.

What about x100 and a bigger target?

We also tested the version where €100 at x100 is meant to make €50 a day. Because one-hour candles can hide what happens inside the hour, we re-ran it on 1-minute data.

0 of 54 setups made money. The best lost €9.07 a day, which adds up to -€9,444 over the period.
Without a stop, the position was liquidated on 53 to 61% of days.
Days that reached +€50 happened 13 to 47% of the time, about the same as a coin flip.

One setup looked profitable on hourly data with optimistic fill assumptions (+€5.75 a day). On 1-minute data it lost €9.96 a day. The hourly result came from not seeing the path inside each candle. That's a useful warning if you backtest leveraged strategies on large timeframes.

The arithmetic at x100: liquidation comes about 0.5% away, and the target needs about +0.6% after fees. That's close to a 45/55 race against you. A win pays €50 and a loss costs €100, so you'd need to win about two times out of three just to break even.

What we'd take from this

A fixed daily target doesn't fit with leverage. The market doesn't care about your target. Forcing a trade every day until you hit it piles up exactly the losing days that liquidate you.
Judge a leveraged strategy by its worst days, not its hit rate. A strategy that wins 86% of its days can be a disaster. Count liquidations, and compare the result with a coin flip on the same settings.
Size by risk, not by target. Decide what you can lose on a trade first, then work out the position. Our guide to position sizing and the 1% rule goes through how.
Test on fine data. Leveraged results on hourly or daily candles can be fiction. Check them on 1-minute data before you believe them.

If a +10%-a-day strategy existed and held up, it would compound €100 into more money than exists within a year. That alone tells you something about the claims you see in ads.

We ran a similar test on frequent trading without leverage: 2,160 crypto scalping strategies against retail fees. It ends in the same place: costs and losing days decide the result, not the hit rate.

This article describes historical simulations for educational purposes. It isn't investment advice, and simulated results don't predict future returns. Leveraged trading can lose your whole stake quickly. If you trade, test on a demo account first and only risk money you can afford to lose.

Originally published on edgoro.com.

We backtested 2,160 crypto scalping strategies on 1-minute data. None of them beat the fees.

Walid Koussa — Tue, 10 Nov 2026 12:17:33 +0000

Ask traders what their first bot should do and a lot of them describe the same thing: scalp the 1-minute chart on crypto and make a little money every day. Edgoro can write that code in a couple of minutes. The question we kept asking ourselves was whether a bot like that can make money at all once you pay what a normal account pays.

So we stopped guessing and ran the test properly. About 2,160 strategy configurations, close to three years of 1-minute candles on BTC, ETH and SOL, real fee levels, fills that don't flatter the result, and a final test period that stayed locked until the very end.

Short version: nothing that trades often survived. Below is what we tested, the one number that explains most of it, and the single idea that wasn't dead (and why we still don't call it a winner).

The setup


Market	Binance spot: BTCUSDT, ETHUSDT, SOLUSDT
Data	1-minute candles, 1 Jan 2024 to 7 Nov 2026, 1,500,480 minutes per coin, no gaps
Timeframes	1, 3, 5 and 15 minutes (built from the 1-minute data)
Development period	1 Jan 2024 to 30 Jun 2025
Sealed test period	1 Jul 2025 to 7 Nov 2026 (495 days), opened once, at the end
Retail cost	0.10% fee per side + 0.01% slippage = 0.22% per round trip
Other cost levels	BNB discount (0.17% round trip), maker orders at 0.075%, VIP maker at 0.02%

Two rules did a lot of the work, so they're worth spelling out.

Fills. A market order fills at the open of the next minute, never at the close you just saw. A limit order only counts as filled if the price trades at least one tick through it. Touching your price isn't enough, because in a real order book you're standing in a queue and a touch often leaves you unfilled. When a stop and a take-profit both sit inside the same candle, we assume the stop hit first.

No peeking. The development data was used to pick and tune ideas. The last 16 months were sealed: the scripts that searched for strategies never loaded them. Before we opened them we wrote down which finalists would be tested and what "pass" meant (positive return, Sharpe of at least 0.5, positive average trade, at least two of three coins positive, drawdown smaller than 15%). Then the sealed period was opened once.

We also checked the engine itself. A strategy that cheats by looking at the next candle wins 98.4% of its trades in this engine. The same rule restricted to information that was actually available wins 49% and goes nowhere. Random entries lose exactly the fees. That's what you want to see before trusting any result.

The number that decides everything

Before testing any strategy, we asked a simpler question: how much is there to catch on a 1-minute chart?

We gave a hypothetical bot perfect foresight of the next candle. It knows whether the next minute closes up or down and trades it. On average, that perfect bot makes 0.066% per trade on 1-minute candles, and 0.146% on 5-minute candles.

A retail round trip costs 0.22%.

So even a bot that never gets a single direction wrong loses money on the 1-minute chart at retail fees. The average move is about a third of the cost. A real strategy only catches part of that move, while paying the full fee every time. It has to find rare, unusually large moves, or it can't win.

That one comparison explains most of what follows. If you only take one thing from this post, run the same check on your own market and timeframe: average absolute move per bar against your round-trip cost.

What we tried

The search ran in five rounds. Each round looked at what the previous one found and went after effects big enough to pay for the fees.

Round	What we tested	Configurations	Result
1	The classic scalpers: RSI(2), Bollinger and Keltner fades, VWAP mean reversion, range breakouts with volume or order-flow confirmation, session-open breakouts, start-of-hour drift, momentum bursts, simple market making	131	Nothing positive under any fee level. Typical edge before fees: 0 to 0.07% per trade, against 0.17 to 0.22% of costs
2	Bigger effects only: spike fades, extreme distance from VWAP, 15-minute momentum, wide quotes, deep limit orders	620	First positives, all on rare events (one trade every 3 to 10 days). Fell apart in rolling tests
3	Long-only extreme VWAP fade, spike fade with volatility floor, deep-quote market making	606	VWAP fade positive in development, but 54 to 85% of its profit came from 5 crash days
4	Volatility and time-of-day filters, trailing and fixed exits, a resting "crash bid"	782	Filters added nothing. The crash bid stood out
5	Stress tests on the finalists: delays, 0.05 to 0.25% slippage, double fees, harsher fills, without the best days	25	Only the crash bid held up under every stress

Two findings from those rounds surprised us.

Limit orders made mean reversion worse, not better. Fees are lower with limit orders, so the obvious fix is "just use limits". But a limit order to buy a falling market fills exactly when the price keeps falling through it. The trades you get are disproportionately the bad ones. In our data, random limit entries started about 0.012% worse than random market entries, before fees.

Filters didn't rescue anything. Volatility filters and session filters mostly shrank the sample. The extreme moves that paid only happened when volatility was already high, so the filter was redundant.

The sealed test

Six finalists that use market orders went into the sealed period. All six failed.

Finalist	Development Sharpe	Sealed-period return	Sealed-period Sharpe
VWAP capitulation fade (z below -6)	0.98	+0.8%	0.27
15-minute momentum (reference)	-0.11	+0.6%	0.10
VWAP fade, re-optimised every month	n/a	-4.5%	-0.82
VWAP capitulation fade (z below -5)	1.65	-7.0%	-1.28
5-minute spike fade	1.50	-5.9%	-1.48
Fast VWAP fade (about 1.3 trades a day)	0.43	-28.2%	-2.85

Look at the second and fourth columns. The strategies that looked best during development were not the ones that did best afterwards. The edge before fees of the z-5 fade dropped from 0.52% per trade to 0.08%. That's what overfitting looks like when you finally measure it: the result was mostly the search, not the market.

The only finalist that traded more than once a day lost 28% of the account. Frequency is the enemy here. Every extra trade pays 0.22% whether the idea works or not.

The one idea that wasn't dead: the crash bid

One family behaved differently from the start. Instead of chasing price, it waits.

Every minute, the bot places a buy limit order 2% below the last close and moves it with the market. It only fills when a coin suddenly drops more than 2% within a minute, which mostly happens during liquidation cascades. It then sells at +2%, or at market after four hours if the bounce doesn't come.

In the sealed period, at full retail fees:

	Crash bid (2% below)	BTC buy and hold, same period
Return	+7.0%	-29.2%
Worst drawdown	-1.9%	-53%
Trades	43 in 495 days	n/a
Winning trades	79%	n/a
Average result per trade, after fees	+0.48%	n/a

That looks good. Here is why we don't call it proven:

43 trades is very few. The 95% confidence interval for the average trade runs from -0.26% to +1.14%. Zero is inside it, so statistically we can't rule out that the true edge is nothing.
The profit sits on a handful of days. 10 October 2025, one of the biggest liquidation days on record, made +2.4% of the +7.0% by itself. Without the five best days, the total drops to +1.3%.
We knew those crashes happened. When we ran the test, we already knew the sealed period contained big liquidation events. The finalists were chosen from development data, and the crash bid was already the strongest family there, but that knowledge could still have nudged us towards crash-buying ideas.
Real fills may be worse. One-minute candles don't show the order book. In a real crash, thousands of resting bids sit at the same levels, and not all of them fill.

It also isn't a scalper in the usual sense. It's in cash 99.8% of the time and trades once every 11 days or so across three coins. We're now running it as a forward paper test on live prices, with the rules frozen, because only new data can tell whether the result was real.

What this means if you want a scalping bot

Here's what we'd take from all this before writing a single line of bot code:

Compare the average move to your round-trip cost. If the average bar on your timeframe moves less than your fees, frequent trading is a fight you start from behind. Use the expectancy calculator to see what win rate and payoff you'd need.
Count your trades. At 0.22% per round trip, 5 trades a day costs about 1.1% of the position every day in fees and slippage. Most scalping ideas don't produce that much edge in a week.
Keep a period you never look at. Tune on one stretch of data, test once on another. If you keep re-testing on the "test" period, it stops being a test.
Model fills pessimistically. Next-bar fills for market orders, a tick through for limits, stop before target when both are inside the same candle. Most dream backtests die on these three rules alone. Our list of backtesting mistakes that inflate results goes through the others.
Check how much of the profit comes from the best few days. If removing five days removes the edge, you're looking at an event strategy, and you should size it and judge it like one.
Be wary of a high win rate. The crash bid wins 79% of the time and is still statistically unproven. A bot that wins 90% of its trades can lose money if the losers are big enough.

None of this says short-term trading can't work for anyone. Market makers with rebates, firms sitting next to the exchange's servers and traders with real information do make money there. It says that a retail account paying retail fees, running a 1-minute pattern bot, faces a cost it almost certainly can't cover.

How we'd test your idea instead

If you have a strategy in mind, describe it in plain English to the crypto bot builder and run it through the Backtest Lab. Fees and slippage are included, and the lab holds back an out-of-sample period and tells you plainly when a result looks like luck. It's the same discipline we used here, just faster.

This article describes historical simulations for educational purposes. It isn't investment advice, and past results, simulated or real, don't predict future returns. Trading crypto, especially with leverage, can lose you more than you expect. Test everything on a demo account first.

Originally published on edgoro.com.