Trading bot risk management: limits, stops and kill switches

Why risk management matters more than the strategy

New bot builders spend ninety percent of their effort searching for a winning signal and almost none deciding what happens when that signal is wrong. This is backwards. A strategy with a genuine edge can still ruin you if a single trade is allowed to be large enough, and a strategy with no edge at all can break even for a long time under tight risk limits. The reason is simple arithmetic: losses compound against you faster than gains compound for you. A 50% drawdown requires a 100% gain just to get back to flat. Risk management is the discipline of never giving a drawdown the chance to get that deep.

The other reason is that a bot fails in ways a human discretionary trader rarely does — it can fire the same broken order a thousand times a second, keep buying into a stale price feed, or hold a position through a flash crash because nobody was watching. Your risk layer is the only thing standing between a normal bad day and a catastrophe. Build it first, before you optimise a single parameter for returns.

The fixed-fractional rule: risk a small slice per trade

The foundation of position sizing is the fixed-fractional rule: on every trade, risk a fixed percentage of your current account equity — typically between 0.5% and 2% — rather than a fixed dollar amount or a fixed number of contracts. "Risk" here means the loss you take if price hits your stop, not the size of the position. Because the fraction is applied to current equity, your bet size shrinks automatically after losses and grows after wins, which is exactly the behaviour that prevents a losing streak from accelerating into ruin.

The math to convert a risk fraction into a position size is mechanical: units = (equity × risk%) ÷ (entry − stop). The distance between your entry and your stop sets how many units that fixed dollar risk buys. A tight stop lets you hold a larger position for the same risk; a wide stop forces a smaller one. Our free position-size calculator does this for you, and we walk through the edge cases in position sizing for trading bots.

Risk a fraction of equity, not a fixed amount. The fraction is your speed limit — it doesn't guarantee profit, but it guarantees you'll still be trading after the inevitable cold streak.

Per-trade stop-losses define the risk

A position size is meaningless without a predefined exit, because the stop is what makes the loss fixed. Every trade your bot opens should carry a stop-loss decided before entry and submitted to the exchange as an order, not held in your bot's memory where a crash or disconnect can lose it. A stop that only exists in your running process is not a stop — it's a hope. Where possible, place a resting stop order on the venue so the protection survives your bot going offline.

Set the stop on market structure or volatility, not on the dollar amount you're willing to lose; the dollar amount is the output of the stop distance and your risk fraction, never the input. A common approach is a multiple of recent average true range, which adapts the stop to current volatility rather than using an arbitrary fixed percentage that's too tight in calm markets and too loose in violent ones.

Max daily loss limit and the circuit breaker

Sizing each trade well is not enough, because trades cluster: a bad regime, a broken model, or a data outage can produce a string of losers in a single session. A max daily loss limit is the circuit breaker that caps the damage. Pick a threshold — many practitioners use something on the order of 3% to 6% of equity, or a multiple of their average daily expectation — and when realized plus open losses for the day cross it, the bot stops opening new trades until the next session resets. This single rule turns "the day my model broke" from an account-ending event into a bad-but-survivable one.

Exposure caps and correlation risk

Sizing controls each trade; an exposure cap controls the whole book. Decide the maximum number of concurrent positions and the maximum total capital (or notional, under leverage) the bot may have at risk at once. Without this, a strategy that fires many signals in a trending market can quietly stack ten positions and turn a 1%-per-trade plan into a 10% bet on a single market move.

This is where correlation risk bites, and it's the trap that catches people running several bots. If you trade five crypto pairs, or run three "different" strategies that all go long in the same conditions, you do not have five independent 1% risks — in a sharp sell-off they all lose together, and your real exposure is far closer to a single 5% bet. The fix is to cap exposure per cluster of correlated instruments, not just per symbol, and to treat a portfolio of bots as one combined risk budget rather than several separate ones. The point of diversification is broken the moment everything moves as one.

The kill switch: stop everything, now

No matter how careful your code, something will eventually happen that you didn't anticipate — an exchange returns garbage prices, a deploy ships a bug, or a market event makes your assumptions nonsense. A kill switch is a single control that immediately halts all new orders and, ideally, flattens open positions, without you having to read code or redeploy. Implement it as a flag the bot checks at the top of every loop: a file, a database value, or a remote endpoint you can flip from your phone. The whole point is that in the moment you need it, you are panicking and have no time to debug — the off button must already exist and be trivial to hit.

A risk-check function in code

Risk rules belong in one place, checked before every order, so no trade can ever bypass them. Here is a compact gatekeeper that rejects a trade if it would breach the daily loss limit or the total-exposure cap, or if the kill switch is engaged. Your strategy logic never sends an order directly — it asks this function first.

python · risk.pydef approve_trade(equity, day_pnl, open_risk, new_risk, kill=False):
    """Return (ok, reason). Strategy must call this before every order."""
    MAX_DAILY_LOSS = -0.05 * equity   # circuit breaker: -5% of equity
    MAX_EXPOSURE   =  0.10 * equity   # total capital at risk cap: 10%

    if kill:
        return False, 'kill switch engaged'
    if day_pnl <= MAX_DAILY_LOSS:        # incl. open mark-to-market loss
        return False, 'daily loss limit hit'
    if open_risk + new_risk > MAX_EXPOSURE:
        return False, 'exposure cap exceeded'
    return True, 'ok'

ok, why = approve_trade(equity=10000, day_pnl=-120,
                       open_risk=600, new_risk=200)
if ok:
    place_order(...)          # only path to a live order
else:
    log(f'trade rejected: {why}')

Keep the limits as named constants in one config, log every rejection with its reason, and make the kill flag something an external process can set. The function is deliberately boring — risk code should be the most obvious, most tested, least clever code in your project.

Drawdown limits and risk-of-ruin intuition

Your per-trade fraction quietly decides how long you can survive a cold streak. The intuition is captured by risk of ruin: the smaller the slice you risk per trade, the longer the run of consecutive losses you can absorb before a drawdown becomes dangerous. The table below shows roughly how many losing trades in a row it takes to lose half the account at different fixed-fractional settings — a back-of-envelope way to feel why professionals keep the number small.

*Illustrative: consecutive full-stop losses with each loss applied to the reduced balance. Real outcomes depend on win rate, payoff ratio and how losses cluster. The point is the shape, not a precise count.

On top of per-trade sizing, set a hard maximum drawdown limit for the whole account — say, a peak-to-trough decline at which the bot stops entirely and you review what changed. A daily limit caps a bad session; a drawdown limit catches the slower failure where a strategy quietly stops working and bleeds out over weeks. The relationship between return and risk-taken is also what a metric like the Sharpe ratio tries to capture — a high return earned through wild swings is not the same as a steady one.

Leverage is a risk multiplier, not free money

Leverage does not improve a strategy; it amplifies whatever the strategy already does, in both directions, and adds a failure mode spot trading doesn't have — liquidation. At 10x, a 10% move against you can erase the position entirely before your stop matters. Leverage doesn't change the fixed-fractional rule — you still risk a small fraction of equity per trade — but it dramatically shrinks the price move that produces that loss, so stops must sit closer and your exposure cap must be more conservative, measured in notional rather than margin posted. Treat leverage as a tool to fine-tune capital efficiency on an already-profitable, well-risk-managed system, never as a way to manufacture returns from a thin edge. If you're reaching for leverage to make the numbers work, the numbers don't work.

Frequently asked questions