The Struggle (Before):

I subscribed to a WebSocket feed, naively assumed each message arrived in chronological order, and updated my internal price series like this:

# ❌ Dangerous! Assumes monotonic timestamps
def on_tick(tick):
    last_price = tick['price']
    self.price_history.append(last_price)   # just append
    if len(self.price_history) > 20:
        self.price_history.pop(0)
    # ... calculate SMA, make decision ...

The Victory (After):

I now treat each tick as a timestamped event and maintain a sorted buffer. If a tick arrives late, I either discard it or re‑play the missing interval—just like Neo learning to see the flow of code.

# ✅ Robust handling of out‑of‑order ticks
from bisect import bisect_left
import heapq

class TickBuffer:
    def __init__(self, max_seconds=5):
        self.max_seconds = max_seconds
        self._heap = []          # min‑heap of (timestamp, price)
        self._sorted = []        # timestamps in ascending order

    def add_tick(self, ts, price):
        # Insert while keeping heap invariant
        heapq.heappush(self._heap, (ts, price))
        # Keep only recent ticks
        cutoff = ts - self.max_seconds
        while self._heap and self._heap[0][0] < cutoff:
            heapq.heappop(self._heap)
        # Rebuild sorted list for indicator calc
        self._sorted = sorted(self._heap, key=lambda x: x[0])

    def recent_prices(self, n=20):
        return [price for _, price in self._sorted[-n:]]

The Struggle (Before):

I had a simple mean‑reversion rule: “If price deviates > 2 % from the 20‑period SMA, go opposite.” I coded it as a static constant:

# ❌ Fixed threshold – works fine in calm markets, deadly in storms
DEVIATION_THRESHOLD = 0.02   # 2%

def should_trade(price, sma):
    deviation = abs(price - sma) / sma
    return deviation > DEVIATION_THRESHOLD

The Victory (After):

I made the threshold adaptive—scaled to recent volatility (ATR or standard deviation). Now the bot only triggers when the move is statistically significant, not just a arbitrary percent.

import numpy as np

class AdaptiveThreshold:
    def __init__(self, lookback=50, k=2.0):
        self.lookback = lookback
        self.k = k                  # number of std‑devs
        self.prices = []

    def update(self, price):
        self.prices.append(price)
        if len(self.prices) > self.lookback:
            self.prices.pop(0)

    def threshold(self, sma):
        if len(self.prices) < self.lookback:
            return np.inf          # not enough data yet
        std = np.std(self.prices)
        return self.k * std / sma   # dynamic band as fraction of SMA

def should_trade(price, sma, adapthr):
    deviation = abs(price - sma) / sma
    return deviation > adapthr.threshold(sma)

The Struggle (Before):

I fired a market order every time my signal flipped, without checking if I already had an open position or a pending order. In a rapid‑fire scenario (think Mad Max: Fury Road chase), I’d end up with multiple overlapping orders, causing accidental double‑fills or, worse, short‑selling when I intended to be long.

# ❌ No idempotency check – dangerous on signal chatter
def on_signal(new_signal):
    if new_signal == 'BUY' and not self.long:
        self.exchange.place_market_order('BUY', self.qty)
        self.long = True
    elif new_signal == 'SELL' and self.long:
        self.exchange.place_market_order('SELL', self.qty)
        self.long = False

The Victory (After):

I introduced a simple order token (client‑order ID) and a state machine that guarantees at most one active order per direction. I also made the submission function idempotent by checking the exchange’s open‑order list before sending a new request.

import uuid

class TradingEngine:
    def __init__(self, exchange):
        self.exchange = exchange
        self.client_orders = {}   # side -> client_order_id
        self.position = 0         # +long, -short, 0 flat

    def _cancel_if_needed(self, side):
        cid = self.client_orders.get(side)
        if cid:
            try:
                self.exchange.cancel_order(cid)
            except Exception:
                pass   # best effort; we’ll clean up on next tick
        self.client_orders.pop(side, None)

    def submit_order(self, side, qty):
        # Idempotent: if we already have an open order for this side, do nothing
        if side in self.client_orders:
            return self.client_orders[side]

        self._cancel_if_needed(side)   # clean opposite side if needed
        cid = str(uuid.uuid4())
        resp = self.exchange.place_market_order(side, qty, client_order_id=cid)
        self.client_orders[side] = cid
        # Update position optimistically; will be reconciled on fill
        self.position = qty if side == 'BUY' else -qty
        return cid

    def on_signal(self, new_signal):
        if new_signal == 'BUY' and self.position <= 0:
            self.submit_order('BUY', self.qty)
        elif new_signal == 'SELL' and self.position >= 0:
            self.submit_order('SELL', self.qty)