How to backtest a crypto trading strategy without fooling yourself

How do you backtest a crypto trading strategy? Write the rules down so precisely that a computer can follow them, run them over past prices, and charge every simulated trade what it would have cost: exchange fees, funding for every hour a position was open, and slippage on each fill. Then test the same rules on data you didn’t use to build them. Most backtests that look good fail one of those steps: they peek at data the strategy couldn’t have known, test only the coins that survived, leave out costs, or tune the rules until they fit the past.

Backtest a crypto strategy, step by step

1. 01Write the rules. Entry, exit, stop, size and the markets it trades, with no room for judgement. If you can’t write it in a sentence or two, a script can’t run it either.
2. 02Get the data. Hyperliquid’s free info API returns candles (the most recent 5,000 per market and interval: about 208 days of hourly candles, or every daily candle since the market listed) and hourly funding history. Include markets that have since been delisted, if you can get their history.
3. 03Model the costs. Fees at the tier you will actually trade, funding for every hour held, and slippage from the order book for your size (tables below).
4. 04Simulate fills honestly. Act on the next candle after a signal, not the candle that produced it, and when a stop and a target fall inside the same candle, assume the stop filled first.
5. 05Split the data. Build on the first part (in-sample), then run the finished rules once on the rest (out-of-sample). Better still, walk forward: re-fit on a rolling window and test on the period after it.
6. 06Judge the result on profit factor, max drawdown, the Calmar ratio and the number of trades, against simply holding the market.
7. 07Run it small. Live trading adds what a backtest can’t: queue position, partial fills and your own reactions. Start with a size you can afford to be wrong with.

Where Senpi fits

Senpi doesn’t run backtests for you; Simulations, paper trading with simulated money, are coming. Until then, you can write and run one with an AI coding assistant such as Claude or ChatGPT; How to use AI for quant trading strategies walks through it, including the checks above. Some templates in the open-source senpi-skills library cite a historical replay in their notes; read that as the author’s evidence, and test it yourself.

When the rules hold up, describe them to your Senpi agent, in the app or from Claude or ChatGPT through Senpi Connectors. The agent asks about one decision at a time and reads the full rules back to you to confirm before it writes any code. Entries go maker-first, with a taker fallback; stops fill as market orders and pay the taker fee, so charge every stop-out at the taker rate in your test. On Senpi, a strategy you confirm runs as code on Senpi’s runtime, and by default no AI model makes live trading decisions. Strategies built from a rule or a template carry the Dynamic Stop-Loss (DSL) from the first fill, and each can have its own daily-loss halt, which lifts at the next UTC midnight, or a drawdown halt, which waits until you resume it. Copy strategies carry at most a flat stop. Each strategy trades from its own strategy wallet; the agent holds no key and cannot withdraw.

The costs to put in every backtest

Costs decide whether a small edge survives. A rule that makes two round trips a day with taker orders pays 4 × 0.045% = 0.18% of the position a day in fees alone, about 66% a year at 1x. On a market like CC, where a $10,000 market order cost 11.3 bps at the snapshot, the same rule gives away about 0.63% a day. The full fee schedule, with volume tiers and discounts, is in Hyperliquid fees explained.

Slippage: what a market buy cost at the snapshot

Seven ways a backtest fools you

In-sample, out-of-sample and walk-forward testing

In-sample data is what you build and tune the rules on. Out-of-sample data is history you keep back and use once, at the end, to see whether the rules still work. If you go back and tune after looking at the out-of-sample result, it becomes in-sample. Walk-forward testing repeats the split: fit on a rolling window, such as a year, test on the next quarter, move forward and repeat. A rule that only works in-sample has learned the noise of the past.

1. 01Pick the windows. For example, tune on 12 months and test on the 3 months that follow. Hyperliquid’s 5,000-candle limit gives about 208 days of hourly candles, so hourly strategies need shorter windows or data you collect yourself.
2. 02Tune, then freeze. Choose the parameters on the in-sample window only, and don’t touch them during the test window.
3. 03Roll forward. Move both windows on by the length of the test window and repeat until you reach today.
4. 04Judge the stitched result. Join the out-of-sample pieces into one equity curve. That curve, not the in-sample one, is your backtest.
5. 05Compare the two. If the out-of-sample results are far worse than the in-sample ones, the tuning found noise.

Monte Carlo: how bad could the drawdown have been?

A backtest gives you one equity curve, but the same trades in a different order would have produced a different drawdown. A Monte Carlo test resamples your trades, or daily returns, thousands of times and records the max drawdown of each version. The spread of results is a better guide to what you might sit through than the single number your backtest printed. Plan for the bad tail, not the median.

BTC’s actual path fell 44.7% from its peak, but in the worst 5% of reshuffled years the same daily moves produced a drawdown of 71.1% or more. Simple resampling treats every day or trade as independent, which breaks up losing streaks and calm and wild spells; resampling blocks of consecutive days or trades keeps more of that structure.

import numpy as np

def monte_carlo_drawdowns(trade_returns, runs=10_000, seed=42):
    """Resample per-trade returns (fractions of equity, after costs) to see the range of max drawdowns."""
    rng = np.random.default_rng(seed)
    r = np.asarray(trade_returns, dtype=float)
    sims = rng.choice(r, size=(runs, len(r)), replace=True)          # draw trades with replacement
    equity = np.hstack([np.ones((runs, 1)), np.cumprod(1 + sims, axis=1)])
    max_dd = (equity / np.maximum.accumulate(equity, axis=1) - 1).min(axis=1)
    worst_5, median, best_5 = np.percentile(max_dd, [5, 50, 95])
    return {"worst 5%": round(float(worst_5), 3), "median": round(float(median), 3), "best 5%": round(float(best_5), 3)}

# trades = your backtest's trade log, e.g. [0.012, -0.006, 0.031, -0.009, ...]
# print(monte_carlo_drawdowns(trades))

How to judge the result

• Profit factor above 1 means the winners outweigh the losers after costs; profit factor explained.
• Max drawdown is the deepest fall from a peak; decide in advance the drawdown you would actually sit through (max drawdown explained).
• Calmar ratio divides the yearly return by the max drawdown, so you can compare strategies with different risk (Calmar ratio explained).
• Against buy-and-hold: a strategy that makes less than holding the market, with a deeper drawdown, isn’t worth running.
• Stability: small changes to the parameters should change the result a little, not flip it.

This page explains how to test a trading strategy on historical data. It is not financial advice, and the market readings are data, not trade signals. Leveraged perps can lose money quickly.