DEV Community: Holdy Lab

Why 20 Trades Prove Nothing: Sample Size for Trading Behavior (in 25 Lines of Python)

Holdy Lab — Wed, 14 Oct 2026 09:42:17 +0000

Series: Measuring trader behavior.
Disclosure: I work on Holdy Lab, a behavioral analysis tool for traders. The code below is open (MIT) and you do not need our product to run it. Educational only, not financial advice.*

"My win rate is 60%." Over how many trades? That single question decides whether the number means anything. Traders routinely draw conclusions from 15 or 20 trades, and the same reasoning shows up in "I trade best on Tuesdays" or "I revenge trade after losses". Here is a small way to see how much a number can be trusted before you act on it.

A win rate is a range, not a number

If you win 12 of 20 trades, your observed win rate is 60%. The true win rate of your strategy, the one you would see over thousands of trades, could be quite different. A standard way to express that is a confidence interval. I use the Wilson score interval because it behaves well for small samples and for rates near 0% or 100%, where the textbook formula misbehaves.

from math import sqrt


def wilson(wins: int, n: int, z: float = 1.96) -> tuple[float, float]:
    """95% Wilson score interval for a win rate observed as `wins` out of `n` trades."""
    if n == 0:
        return (0.0, 1.0)
    p = wins / n
    denom = 1 + z * z / n
    centre = (p + z * z / (2 * n)) / denom
    half = z * sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / denom
    return (centre - half, centre + half)


def streak_probability(n_trades: int, streak: int, win_rate: float) -> float:
    """Chance of at least one run of `streak` losses within `n_trades` independent trades."""
    q = 1 - win_rate
    state = [1.0] + [0.0] * (streak - 1)  # state[i] = current losing run has length i and never reached `streak`
    for _ in range(n_trades):
        nxt = [0.0] * streak
        for i, prob in enumerate(state):
            nxt[0] += prob * (1 - q)
            if i + 1 < streak:
                nxt[i + 1] += prob * q
        state = nxt
    return 1 - sum(state)

Running it on a 60% observed win rate:

  20 trades, 60% observed -> plausible true win rate 38.7% to 78.1%
  50 trades, 60% observed -> plausible true win rate 46.2% to 72.4%
 100 trades, 60% observed -> plausible true win rate 50.2% to 69.1%
 200 trades, 60% observed -> plausible true win rate 53.1% to 66.5%
 400 trades, 60% observed -> plausible true win rate 55.1% to 64.7%

After 20 trades, a "60% strategy" could be a coin flip or an excellent system, and the data cannot tell you which. The range narrows slowly: you need roughly four times the trades to halve its width.

Streaks are normal

The same small-sample thinking applies to losing streaks. streak_probability computes the chance of at least one run of N losses somewhere in M trades, exactly, by tracking the current run length as the trades go by.

P(at least 6 losses in a row in 100 trades at 50%) = 54.6%
P(at least 10 losses in a row in 100 trades at 50%) = 4.4%

Even with a 50% win rate, a run of six losses somewhere in 100 trades is more likely than not. If six losses in a row makes you abandon a sound plan, you will keep abandoning plans that were fine.

What to do with this

Report ranges, not points. Write "52% to 70%" in your journal, not "61%".
Set a minimum before judging. Many people use at least 50 trades for an early look and 100 or more before changing a strategy. There is no magic number; the interval tells you how wide your uncertainty still is.
Apply it to behavior, not only to strategy. "I size up after losses" is also an estimate from a sample. Eight trades in each group is a floor, not a comfortable size.
Look for large, repeated effects. Small differences need big samples.

Limits

The interval assumes trades are independent and that the strategy does not change. Real markets have regimes, so the true uncertainty is larger than the table shows.
The streak calculation assumes a constant win rate and independent trades.
Neither tells you why a result happened.

The tests and two more checks (a prop-firm Monte Carlo and a weekday permutation test) are in the open repository. If you would rather not run code, the free Trade Analyzer labels results by sample size, and how many trades you need to evaluate a strategy explains the same idea without code.

How to measure revenge trading from a trade history (in 40 lines of Python)

Holdy Lab — Thu, 08 Oct 2026 13:02:36 +0000

Disclosure: I work on Holdy Lab, a behavioral analysis tool for traders. The method below is the same one our Trade Analyzer uses, simplified. You do not need our product to run it.

Everyone agrees revenge trading is bad. Almost nobody measures it. Journals say "I broke my rule", which is a statement about one trade. The useful question is whether it happens systematically: after a loss, do you trade differently from after a win?

That is measurable from a plain trade history. Here is a small method, its reasoning and its limits.

The two signatures

Revenge trading is usually described as trading to win back a loss, with a larger size, faster entry and weaker setups. Two of those can be read straight from exported trades:

Position size after a loss versus after a win.
Waiting time before the next trade after a loss versus after a win.

The key design choice: compare a trader with themselves, split by what the previous trade did. A trader who always sizes big, or always trades fast, is not revenge trading. A trader whose size and speed change after a loss, relative to after a win, might be.

Why medians, why "after a win" as the control

Medians, not means. One oversized trade should not decide the result.
Control group = trades after a win. Comparing with all other trades mixes in the first trade of a session, trades after breakeven and so on. Win versus loss isolates the one thing you want to test.
Minimum group size. With fewer than about eight trades on either side, a median is noise. The code refuses to answer instead of guessing.

The code

import pandas as pd

MIN_GROUP = 8          # trades needed on each side of the comparison
SIZE_CHANGE = 0.15     # size after a loss at least 15% above size after a win
REENTRY_SPEEDUP = 0.25 # wait after a loss at least 25% shorter than after a win


def revenge_signs(trades: pd.DataFrame) -> dict:
    """trades needs: opened_at, closed_at (datetimes), pnl, notional (position value)."""
    t = trades.sort_values("opened_at").reset_index(drop=True)
    prev_pnl = t["pnl"].shift(1)
    after_loss = t[prev_pnl < 0]
    after_win = t[prev_pnl > 0]
    out = {"n_after_loss": len(after_loss), "n_after_win": len(after_win)}
    if min(out["n_after_loss"], out["n_after_win"]) < MIN_GROUP:
        out["verdict"] = "not enough trades to say anything"
        return out

    size_change = after_loss["notional"].median() / after_win["notional"].median() - 1
    gap = (t["opened_at"] - t["closed_at"].shift(1)).dt.total_seconds()
    wait_loss = gap[(prev_pnl < 0) & (gap >= 0)].median()
    wait_win = gap[(prev_pnl > 0) & (gap >= 0)].median()
    speedup = 1 - wait_loss / wait_win

    out.update(size_change=round(float(size_change), 3), reentry_speedup=round(float(speedup), 3))
    out["size_sign"] = bool(size_change >= SIZE_CHANGE)
    out["reentry_sign"] = bool(speedup >= REENTRY_SPEEDUP)
    return out

Input is a table with when each trade opened and closed, its profit or loss, and its position value. Most exchange exports contain these or something close to them.

The thresholds (15% bigger size, 25% shorter wait) are choices, not laws. They are deliberately conservative so that a small drift does not get labelled. Change them and see how the verdict moves.

What it cannot tell you

Intent. It sees behavior, not motive. Fast re-entry after a loss can be a legitimate plan.
Stop-loss behavior and entry context. Exports rarely include stop orders or what the price did before your entry, so it cannot see moved stops or chasing a move.
Small samples. Under about 50 trades, read any result as an early sign. Under 20, treat it as nothing.
Causality. It says your size and speed differ after losses. It does not say that is why you lost money.

What to do with the result

Do not treat a positive result as a verdict. Treat it as a hypothesis to test: write one rule (a pause after a loss, a size cap), apply it for a fixed number of trades, then run the same measurement again. If the numbers move and hold, the rule works for you. If not, change the rule, not your opinion of yourself.

If you would rather not run code, our free Trade Analyzer runs these two checks and thirteen more on an exported file, and processes it in memory without storing the file. The longer explanation of how we build findings is in our write-up of the framework.

Not financial advice. This measures past behavior in the data you give it and does not predict results.