Start from the task, not the strategy

Ask a trader what a bot does and you get a strategy: it buys breakouts, it fades extremes. Ask the person who has to keep it running and you get a different list: what happens when the exchange times out, what happens when it fills half an order, what happens at 3am when nobody is looking.

That second list is most of the work. So we start there.

Three questions before any code#

1. What is the bot for? Collecting a yield, testing an idea, cleaning up an account, watching a feed. Different jobs, different bots.
2. What is it allowed to lose? In money, in a day, in a row. This becomes numbers in the risk layer before the first order exists.
3. What must it never do? Hold a position without a stop. Trade something not on a list. Send money out. These become code paths that do not exist.

Bot types we tailor to a task#

Tailoring a ladder#

A classic martingale has no ceiling: each rung doubles the last. For a client who wants ladders, we keep the shape and put one shared stop and one fixed risk budget over the whole thing, so the worst case is known before the first order goes out.

def dca_ladder(entry: float, stop: float, risk_budget: float, *, rungs: int = 4,
               spacing: float = 0.02, mult: float = 1.6, fee_rate: float = 0.0006):
    """Long ladder: rung k rests spacing*k below entry; every rung shares ONE stop.
    Rung k gets a slice of the risk budget proportional to mult**k * (loss per unit
    from rung k to the stop). Sizes grow geometrically, yet if every rung fills and
    the stop hits, the total loss equals risk_budget, never more."""
    prices = [entry * (1 - spacing * k) for k in range(rungs)]
    if prices[-1] <= stop:
        raise ValueError("the deepest rung must sit above the stop")
    loss_per_unit = [p - stop + (p + stop) * fee_rate for p in prices]
    weights = [mult ** k * d for k, d in enumerate(loss_per_unit)]
    total = sum(weights)
    ladder = []
    for k, (p, d, w) in enumerate(zip(prices, loss_per_unit, weights)):
        risk_k = risk_budget * w / total
        ladder.append({"rung": k, "price": p, "qty": risk_k / d, "risk_at_stop": risk_k})
    return ladder

With mult = 2 this is the familiar martingale shape. The difference is the shared stop and the fixed budget. All parameters in the code on this site are illustrative defaults, not recommendations.

Demo first, always#

Every bot runs on a demo or testnet account before it is trusted with real funds. The rest of the bots page and the posts below are about what makes that step worth anything.