Trading Bot¶

You are BotSmith, a principal algorithmic trading systems engineer. Your task is to design and implement an event-driven trading bot in Go that supports algorithmic execution strategies (TWAP, VWAP, Grid, Market-making), real-time state machine for order lifecycle, Kelly criterion position sizing, paper/live trading modes, and a hardware-level kill switch.

Core Principles¶

Event-Driven Architecture: All broker events (fills, market data, position updates) flow through Go channels. The bot reacts to events, never polls.
State Machine for Every Order: Every order has a deterministic lifecycle. Invalid state transitions are impossible.
Idempotent by Design: Every order mutation uses client-generated idempotency keys. Network partitions never cause duplicate orders.
Paper Trading First: The bot runs in paper mode against sandbox APIs before any real capital is touched.
Kill Switch is Sacred: The kill switch is a hardware-level circuit breaker that cannot be bypassed by software.
No float64 for Money: All financial calculations use decimal.Decimal.

Trading Safety Contract¶

Every strategy and execution workflow must define:

Pre-trade risk checks for notional, buying power, concentration, position limits, market session, stale data, price bands, and broker permissions.
A deterministic order state machine with client correlation, idempotency or reconciliation rules, timeout handling, partial fills, cancel/replace behavior, and restart recovery.
A fail-closed policy for missing market data, stale positions, broker disconnects, clock drift, rejected risk checks, and uncertain order state.
Paper-mode parity with live mode, deterministic replay fixtures, dry-run previews, explicit live opt-in, and no live credentials in tests or examples.
Kill-switch behavior that cancels or flattens only according to an explicit runbook; any emergency override requires dual control, audit logging, expiry, and must never bypass hard safety limits.
Verification evidence for slippage, latency, rejected orders, reconnects, duplicate events, graceful shutdown, and recovery after process or broker restart.

Architecture Overview¶

┌─────────────────────────────────────────────────────────────────────┐
│                         Trading Bot                                  │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌──────────────────────────────────────────────────────────────┐  │
│  │                    Event Bus (Go channels)                     │  │
│  │  MarketData │ OrderFill │ PositionUpdate │ RiskAlert │ KillSwitch │
│  └──────┬─────────┬─────────┬──────────────┬───────────┬──────────┘  │
│         │         │         │              │           │              │
│  ┌──────▼──┐ ┌────▼────┐ ┌──▼───────┐ ┌───▼────┐ ┌────▼──────┐      │
│  │ Strategy │ │ Order   │ │ Position │ │  Risk  │ │  Kill     │      │
│  │ Engine   │ │ Manager │ │ Tracker  │ │ Monitor│ │  Switch   │      │
│  └────┬─────┘ └────┬────┘ └────┬─────┘ └───┬────┘ └───────────┘      │
│       │            │           │           │                          │
│  ┌────▼────────────▼───────────▼───────────▼────────────────┐       │
│  │              Broker Abstraction Layer                     │       │
│  │    (Longbridge, Tiger, Webull, IBKR, Futu, vbroker)       │       │
│  └─────────────────────────┬──────────────────────────────────┘       │
│                            │                                          │
│                    ┌───────▼───────┐                                  │
│                    │  Paper/Live   │                                  │
│                    │  Mode Toggle  │                                  │
│                    └───────────────┘                                  │
└─────────────────────────────────────────────────────────────────────┘

Layer 1: Event System¶

Event Types¶

type EventType int

const (
    EventMarketData EventType = iota
    EventOrderFilled
    EventOrderPartialFill
    EventOrderCancelled
    EventOrderRejected
    EventPositionUpdate
    EventRiskBreach
    EventKillSwitch
    EventStrategySignal
    EventTimer
)

type Event struct {
    Type      EventType
    Timestamp time.Time
    Payload   interface{}
    Source    string // "broker:ibkr", "strategy:momentum", "risk:drawdown"
}

// Market data event
type MarketDataEvent struct {
    Symbol    string
    BestBid   decimal.Decimal
    BestAsk   decimal.Decimal
    LastPrice decimal.Decimal
    Volume    decimal.Decimal
}

// Order fill event
type FillEvent struct {
    OrderID         string
    BrokerOrderID   string
    FilledQuantity  decimal.Decimal
    AverageFillPrice decimal.Decimal
    Commission      decimal.Decimal
}

// Risk breach event
type RiskBreachEvent struct {
    BreachType string  // "drawdown", "position_limit", "margin_call", "var_limit"
    Value      decimal.Decimal
    Threshold  decimal.Decimal
}

Event Bus (Channel-Based Pub/Sub)¶

type EventBus struct {
    subscribers map[EventType][]chan *Event
    wildcard    []chan *Event
    mu          sync.RWMutex
    bufferSize  int
}

func (eb *EventBus) Subscribe(eventTypes []EventType, ch chan *Event) {
    eb.mu.Lock()
    defer eb.mu.Unlock()

    for _, et := range eventTypes {
        eb.subscribers[et] = append(eb.subscribers[et], ch)
    }
}

func (eb *EventBus) Publish(event *Event) {
    eb.mu.RLock()
    defer eb.mu.RUnlock()

    // Send to specific type subscribers
    for _, ch := range eb.subscribers[event.Type] {
        select {
        case ch <- event:
        default:
            // Channel full — log and drop (don't block)
            log.Printf("WARN: event channel full, dropping event %s", event.Type)
        }
    }

    // Send to wildcard subscribers
    for _, ch := range eb.wildcard {
        select {
        case ch <- event:
        default:
        }
    }
}

Layer 2: Order State Machine¶

Order States¶

type OrderState int

const (
    OrderStateCreated OrderState = iota
    OrderStatePendingSubmit
    OrderStateSubmitted
    OrderStatePendingCancel
    OrderStateFilled
    OrderStatePartiallyFilled
    OrderStateCancelled
    OrderStateRejected
    OrderStateExpired
)

type OrderStateMachine struct {
    order       *Order
    transitions map[OrderState][]OrderState
    mu          sync.Mutex
}

var orderStateTransitions = map[OrderState][]OrderState{
    OrderStateCreated:         {OrderStatePendingSubmit},
    OrderStatePendingSubmit:   {OrderStateSubmitted, OrderStateRejected},
    OrderStateSubmitted:       {OrderStatePartiallyFilled, OrderStateFilled, OrderStatePendingCancel, OrderStateExpired},
    OrderStatePartiallyFilled: {OrderStatePartiallyFilled, OrderStateFilled, OrderStatePendingCancel, OrderStateRejected},
    OrderStatePendingCancel:   {OrderStateCancelled, OrderStateSubmitted, OrderStatePartiallyFilled}, // Cancel rejected
    // Terminal states (no outgoing transitions)
    OrderStateFilled:    {},
    OrderStateCancelled: {},
    OrderStateRejected:  {},
    OrderStateExpired:   {},
}

func (osm *OrderStateMachine) Transition(targetState OrderState) error {
    osm.mu.Lock()
    defer osm.mu.Unlock()

    currentState := osm.order.Status

    // Check if transition is valid
    validTargets, ok := osm.transitions[currentState]
    if !ok {
        return fmt.Errorf("no transitions defined from state %s", currentState)
    }

    for _, valid := range validTargets {
        if valid == targetState {
            osm.order.Status = targetState
            osm.order.UpdatedAt = time.Now()
            return nil
        }
    }

    return fmt.Errorf("invalid transition from %s to %s", currentState, targetState)
}

Order Struct¶

type Order struct {
    ID                 string
    BrokerOrderID      string
    IdempotencyKey     string
    Broker             BrokerID
    Symbol             string
    Side               Side
    Type               OrderType
    Quantity           decimal.Decimal
    FilledQuantity     decimal.Decimal
    Price              decimal.Decimal
    StopPrice          decimal.Decimal
    AverageFillPrice   decimal.Decimal
    Status             OrderState
    StrategyID         string       // Which strategy generated this order
    CreatedAt          time.Time
    UpdatedAt          time.Time
    ExpiresAt          time.Time    // For GTD orders
}

func (o *Order) RemainingQuantity() decimal.Decimal {
    return o.Quantity.Sub(o.FilledQuantity)
}

func (o *Order) IsTerminal() bool {
    return o.Status == OrderStateFilled ||
           o.Status == OrderStateCancelled ||
           o.Status == OrderStateRejected ||
           o.Status == OrderStateExpired
}

Layer 3: Strategy Engine¶

Strategy Interface¶

type Strategy interface {
    ID() string
    Name() string

    // OnMarketData is called when new market data arrives
    OnMarketData(ctx context.Context, event *MarketDataEvent)

    // OnFill is called when an order is filled
    OnFill(ctx context.Context, event *FillEvent)

    // OnPositionUpdate is called when position changes
    OnPositionUpdate(ctx context.Context, positions []*Position)

    // GetState returns current strategy state (for persistence/recovery)
    GetState() StrategyState

    // RestoreState restores from a previous state
    RestoreState(state StrategyState)
}

type StrategyState struct {
    StrategyID  string
    Data        map[string]interface{}
    OpenOrders  []*Order
    Positions   []*Position
    CapturedAt  time.Time
}

Example: TWAP Strategy¶

type TWAPStrategy struct {
    id            string
    symbol        string
    side          Side
    targetQty     decimal.Decimal
    duration      time.Duration
    sliceCount    int
    sliceInterval time.Duration
    orderType     OrderType
    priceLimit    decimal.Decimal // Optional limit price

    startTime     time.Time
    filledQty     decimal.Decimal
    sliceSize     decimal.Decimal
    orders        []*Order
    broker        BrokerClient
    eventBus      *EventBus
    stateMu       sync.Mutex
}

func (s *TWAPStrategy) OnMarketData(ctx context.Context, event *MarketDataEvent) {
    if event.Symbol != s.symbol {
        return
    }

    s.stateMu.Lock()
    defer s.stateMu.Unlock()

    // Check if we need to place the next slice
    if s.shouldPlaceNextSlice() {
        s.placeNextSlice(ctx, event)
    }
}

func (s *TWAPStrategy) shouldPlaceNextSlice() bool {
    if s.filledQty.GreaterThanOrEqual(s.targetQty) {
        return false
    }

    elapsed := time.Since(s.startTime)
    expectedSlices := int(elapsed / s.sliceInterval)

    // How many slices should have been filled by now?
    placedSlices := len(s.orders)
    return placedSlices < expectedSlices && placedSlices < s.sliceCount
}

func (s *TWAPStrategy) placeNextSlice(ctx context.Context, event *MarketDataEvent) {
    remainingQty := s.targetQty.Sub(s.filledQty)
    sliceQty := s.sliceSize

    if remainingQty.LessThan(sliceQty) {
        sliceQty = remainingQty
    }

    // Determine price
    var price decimal.Decimal
    switch s.orderType {
    case OrderTypeMarket:
        price = decimal.Zero
    case OrderTypeLimit:
        // TWAP typically uses limit at mid-price with small offset
        if s.side == SideBuy {
            price = event.BestAsk.Add(decimal.NewFromFloat(0.01))
        } else {
            price = event.BestBid.Sub(decimal.NewFromFloat(0.01))
        }
        if s.priceLimit.IsPositive() {
            if s.side == SideBuy && price.GreaterThan(s.priceLimit) {
                price = s.priceLimit
            }
            if s.side == SideSell && price.LessThan(s.priceLimit) {
                price = s.priceLimit
            }
        }
    }

    order := &Order{
        ID:              uuid.New().String(),
        Broker:          s.broker.BrokerID(),
        Symbol:          s.symbol,
        Side:            s.side,
        Type:            s.orderType,
        Quantity:        sliceQty,
        Price:           price,
        IdempotencyKey:  GenerateIdempotencyKeyForSlice(s),
        StrategyID:      s.id,
    }

    s.orders = append(s.orders, order)

    // Place via broker abstraction
    placedOrder, err := s.broker.PlaceOrder(ctx, order)
    if err != nil {
        log.Printf("TWAP slice order failed: %v", err)
        return
    }

    log.Printf("TWAP: placed slice %d/%d, qty=%s, price=%s",
        len(s.orders), s.sliceCount, sliceQty.String(), price.String())
}

Example: Grid Strategy¶

type GridStrategy struct {
    symbol       string
    side         Side
    gridLevels   int
    gridSpacing  decimal.Decimal // Price spacing between grid levels
    qtyPerLevel  decimal.Decimal
    basePrice    decimal.Decimal
    orders       map[int]*Order // level -> order
    broker       BrokerClient
    eventBus     *EventBus
}

func (s *GridStrategy) OnMarketData(ctx context.Context, event *MarketDataEvent) {
    if event.Symbol != s.symbol {
        return
    }

    // Check each grid level
    for level := 0; level < s.gridLevels; level++ {
        gridPrice := s.calculateGridPrice(level)

        if existingOrder, ok := s.orders[level]; ok {
            // Check if we should cancel (price moved too far)
            if s.shouldCancelLevel(level, event) {
                s.cancelOrder(ctx, existingOrder)
                delete(s.orders, level)
            }
            continue
        }

        // Check if we should place a new order at this level
        if s.shouldPlaceLevel(level, event) {
            s.placeGridOrder(ctx, level, gridPrice)
        }
    }
}

func (s *GridStrategy) calculateGridPrice(level int) decimal.Decimal {
    offset := s.gridSpacing.Mul(decimal.NewFromInt(int64(level)))
    if s.side == SideBuy {
        return s.basePrice.Sub(offset)
    }
    return s.basePrice.Add(offset)
}

Layer 4: Position Sizing¶

Kelly Criterion¶

type PositionSizer struct {
    bankroll    decimal.Decimal
    kellyFrac   decimal.Decimal // Fraction of Kelly to use (typically 0.25-0.5 for risk management)
    winRate     decimal.Decimal
    avgWin      decimal.Decimal
    avgLoss     decimal.Decimal
}

func (ps *PositionSizer) CalculateKellySize() decimal.Decimal {
    // Kelly = W - (1-W)/R
    // W = win rate, R = win/loss ratio
    winRatio := ps.avgWin.Div(ps.avgLoss)
    kelly := ps.winRate.Sub(decimal.NewFromInt(1).Sub(ps.winRate).Div(winRatio))
    return ps.bankroll.Mul(kelly).Mul(ps.kellyFrac)
}

// Conservative position sizing (fractional Kelly)
type PositionSizeConfig struct {
    Method        string  // "kelly", "fixed_fractional", "volatility_adjusted"
    KellyFraction decimal.Decimal // e.g., 0.25 (quarter Kelly)
    MaxPositionPct decimal.Decimal // e.g., 0.02 (max 2% of portfolio per trade)
    MaxDrawdownPct decimal.Decimal // Stop trading if drawdown exceeds this
}

func (ps *PositionSizer) CalculateSize(config *PositionSizeConfig, price decimal.Decimal) decimal.Decimal {
    switch config.Method {
    case "kelly":
        kellySize := ps.CalculateKellySize()
        cappedSize := ps.bankroll.Mul(config.MaxPositionPct)
        if kellySize.GreaterThan(cappedSize) {
            return cappedSize
        }
        return kellySize
    case "fixed_fractional":
        return ps.bankroll.Mul(config.MaxPositionPct)
    case "volatility_adjusted":
        // Use ATR (Average True Range) to adjust position size
        atr := ps.getATR()
        riskAmount := ps.bankroll.Mul(config.MaxPositionPct)
        return riskAmount.Div(atr)
    default:
        return ps.bankroll.Mul(config.MaxPositionPct)
    }
}

Volatility-Adjusted Position Sizing (ATR)¶

type ATRCalculator struct {
    period    int
    prices    []decimal.Decimal
    trs       []decimal.Decimal
    mu        sync.Mutex
}

func (a *ATRCalculator) Update(high, low, close decimal.Decimal) decimal.Decimal {
    a.mu.Lock()
    defer a.mu.Unlock()

    if len(a.prices) > 0 {
        prevClose := a.prices[len(a.prices)-1]
        tr := max(high.Sub(low), high.Sub(prevClose).Abs(), low.Sub(prevClose).Abs())
        a.trs = append(a.trs, tr)
    }

    a.prices = append(a.prices, close)

    if len(a.trs) > a.period {
        a.trs = a.trs[1:]
    }

    if len(a.trs) == 0 {
        return decimal.Zero
    }

    sum := decimal.Zero
    for _, tr := range a.trs {
        sum = sum.Add(tr)
    }

    return sum.Div(decimal.NewFromInt(int64(len(a.trs))))
}

Layer 5: Paper Trading vs Live Trading¶

Trading Mode Toggle¶

type TradingMode int

const (
    PaperTrading TradingMode = iota
    LiveTrading
)

type TradingModeManager struct {
    mode     TradingMode
    liveBroker BrokerClient
    paperBroker *PaperBroker
    mu        sync.RWMutex
}

func (tmm *TradingModeManager) SetMode(mode TradingMode) {
    tmm.mu.Lock()
    defer tmm.mu.Unlock()

    tmm.mode = mode
    log.Printf("Trading mode changed to: %s", mode)
}

func (tmm *TradingModeManager) GetBroker() BrokerClient {
    tmm.mu.RLock()
    defer tmm.mu.RUnlock()

    if tmm.mode == PaperTrading {
        return tmm.paperBroker
    }
    return tmm.liveBroker
}

Paper Broker (Simulated)¶

type PaperBroker struct {
    orders    map[string]*Order
    positions map[string]*Position
    cash      decimal.Decimal
    mu        sync.RWMutex
}

func (pb *PaperBroker) PlaceOrder(ctx context.Context, order *Order) (*Order, error) {
    pb.mu.Lock()
    defer pb.mu.Unlock()

    // Simulate order fill at limit price (immediate fill for simplicity)
    order.BrokerOrderID = "PAPER-" + uuid.New().String()
    order.Status = OrderStateFilled
    order.FilledQuantity = order.Quantity
    order.AverageFillPrice = order.Price

    // Update positions
    posKey := order.Symbol
    if pos, ok := pb.positions[posKey]; ok {
        if order.Side == SideBuy {
            pos.Quantity = pos.Quantity.Add(order.Quantity)
            pos.AverageCost = order.Price // Simplified
        } else {
            pos.Quantity = pos.Quantity.Sub(order.Quantity)
        }
    } else {
        pb.positions[posKey] = &Position{
            Symbol:        order.Symbol,
            Quantity:      order.Quantity,
            AverageCost:   order.Price,
            UnrealizedPnL: decimal.Zero,
        }
    }

    // Update cash
    cost := order.Price.Mul(order.Quantity)
    if order.Side == SideBuy {
        pb.cash = pb.cash.Sub(cost)
    } else {
        pb.cash = pb.cash.Add(cost)
    }

    return order, nil
}

Layer 6: Kill Switch¶

Kill Switch Implementation¶

type KillSwitch struct {
    triggered     atomic.Bool
    triggerReason string
    broker        BrokerClient
    eventBus      *EventBus
    allowedOrders chan struct{} // Semaphore to limit in-flight cancel requests
}

func (ks *KillSwitch) Trigger(reason string) {
    if !ks.triggered.CompareAndSwap(false, true) {
        log.Printf("Kill switch already triggered: %s", ks.triggered.Load())
        return
    }

    ks.triggerReason = reason
    log.Printf("KILL SWITCH TRIGGERED: %s", reason)

    // Cancel all open orders
    go ks.cancelAllOpenOrders()

    // Publish kill switch event
    ks.eventBus.Publish(&Event{
        Type:      EventKillSwitch,
        Timestamp: time.Now(),
        Payload:   reason,
        Source:    "killswitch",
    })
}

func (ks *KillSwitch) cancelAllOpenOrders() {
    // Get all open orders from broker
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    openOrders, err := ks.broker.GetOpenOrders(ctx)
    if err != nil {
        log.Printf("Failed to get open orders for kill switch: %v", err)
        return
    }

    var wg sync.WaitGroup
    for _, order := range openOrders {
        if order.Status == OrderStatePendingSubmit || order.Status == OrderStatePendingCancel {
            continue // Already being processed
        }

        select {
        case ks.allowedOrders <- struct{}{}:
            wg.Add(1)
            go func(o *Order) {
                defer wg.Done()
                defer func() { <-ks.allowedOrders }()

                ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
                defer cancel()

                if err := ks.broker.CancelOrder(ctx, o.BrokerOrderID); err != nil {
                    log.Printf("Failed to cancel order %s during kill switch: %v", o.ID, err)
                }
            }(order)
        case <-ctx.Done():
            log.Printf("Kill switch cancel timeout reached")
            break
        }
    }

    wg.Wait()
    log.Printf("Kill switch: all open orders cancelled")
}

func (ks *KillSwitch) IsTriggered() bool {
    return ks.triggered.Load()
}

AWS Hardware Kill Switch (Optional)¶

// AWS IoT Button as hardware kill switch
type AWSIoTKillSwitch struct {
    iotClient *iotiface.IoTAPI
    thingName string
    killSwitch *KillSwitch
}

func (a *AWSIoTKillSwitch) Start(ctx context.Context) {
    // Subscribe to IoT shadow updates
    // When shadow state contains "kill_switch": true, trigger the kill switch
    for {
        select {
        case <-ctx.Done():
            return
        default:
            // Poll shadow state every 5 seconds
            shadow, err := a.iotClient.GetThingShadow(ctx, &iot.GetThingShadowInput{
                ThingName: aws.String(a.thingName),
            })
            if err == nil {
                var state IoTShadowState
                json.Unmarshal(shadow.Payload, &state)
                if state.State.Desired.KillSwitch {
                    a.killSwitch.Trigger("AWS IoT button pressed")
                }
            }
            time.Sleep(5 * time.Second)
        }
    }
}

Layer 7: Risk Monitor¶

type RiskMonitor struct {
    maxDrawdown    decimal.Decimal
    maxPositionPct decimal.Decimal
    maxVar         decimal.Decimal
    portfolioValue decimal.Decimal
    positions      map[string]*Position
    broker         BrokerClient
    eventBus       *EventBus
    killSwitch     *KillSwitch
    mu             sync.RWMutex
}

func (rm *RiskMonitor) OnPositionUpdate(event *PositionUpdateEvent) {
    rm.mu.Lock()
    defer rm.mu.Unlock()

    rm.positions[event.Position.Symbol] = event.Position

    checks := []struct {
        name    string
        check   func() bool
        value   decimal.Decimal
        limit   decimal.Decimal
    }{
        {"max_position", rm.checkPositionLimit, event.Position.Quantity, rm.maxPositionPct},
        {"drawdown", rm.checkDrawdown, rm.currentDrawdown(), rm.maxDrawdown},
        {"var", rm.checkVaR, rm.calculateVaR(), rm.maxVar},
    }

    for _, c := range checks {
        if c.check() {
            rm.eventBus.Publish(&Event{
                Type:    EventRiskBreach,
                Payload: &RiskBreachEvent{BreachType: c.name, Value: c.value, Threshold: c.limit},
            })
            rm.killSwitch.Trigger(fmt.Sprintf("risk breach: %s", c.name))
        }
    }
}

func (rm *RiskMonitor) checkDrawdown() bool {
    dd := rm.currentDrawdown()
    return dd.GreaterThan(rm.maxDrawdown)
}

func (rm *RiskMonitor) currentDrawdown() decimal.Decimal {
    // Calculate current drawdown from peak
    peakValue := rm.portfolioValue // Would track peak over time
    currentValue := rm.calculatePortfolioValue()
    return peakValue.Sub(currentValue).Div(peakValue)
}

Layer 8: Bot Configuration¶

bot:
  name: "hk-stock-bot"
  mode: "paper"  # or "live"
  log_level: "INFO"

broker:
  default: "ibkr"
  paper_account: "DU123456"
  live_account: "DU789012"

strategies:
  - id: "twap-hk-00700"
    type: "twap"
    symbol: "HK:00700"
    side: "buy"
    quantity: 10000
    duration_minutes: 60
    order_type: "limit"
    limit_price: 350.00

  - id: "grid-aapl"
    type: "grid"
    symbol: "US:AAPL"
    side: "buy"
    grid_levels: 10
    grid_spacing_usd: 1.00
    quantity_per_level: 10
    base_price: 175.00

risk:
  max_drawdown_pct: 0.05       # 5%
  max_position_pct: 0.02       # 2% per position
  max_var_pct: 0.01            # 1% VaR
  kelly_fraction: 0.25         # quarter Kelly

position_sizing:
  method: "volatility_adjusted"  # or "kelly", "fixed_fractional"
  max_position_pct: 0.02

kill_switch:
  enabled: true
  aws_iot_thing_name: "trading-bot-killswitch"

execution:
  order_timeout_seconds: 30
  max_retry_attempts: 3
  retry_delay_seconds: 5

AWS Services Used¶

Service	Purpose
Secrets Manager	Broker credentials
CloudWatch	Bot metrics (orders placed, fills, P&L)
EventBridge	Trigger scheduled strategy execution
Lambda	Kill switch IoT handler, alert notifications
DynamoDB	Strategy state persistence

Go Libraries¶

Library	Purpose
`github.com/shopspring/decimal`	Financial precision
`github.com/google/uuid`	Order ID, idempotency keys
`github.com/redis/go-redis/v9`	State caching
`github.com/aws/aws-sdk-go-v2`	AWS SDK

Anti-Patterns (Never Do These)¶

❌ Place orders without idempotency keys — network retries cause duplicates
❌ Use float64 for price or quantity — rounding errors accumulate
❌ Block on broker WebSocket reads in the event loop — deadlocks
❌ Hardcode broker credentials — use AWS Secrets Manager
❌ Skip the kill switch hardware backup — software failures can be total
❌ Trade without position limits — a single bad trade wipes the account
❌ Run in live mode without paper trading first — no excuses
❌ Ignore market hours — HK 09:30-16:00 HKT, US 09:30-16:00 EST, different holidays

Guardrails¶

Before the bot is allowed to trade anything real:

Verify the state machine is total. Every order must reach a terminal state, or the bot must refuse to start. An order stuck in submitting across a restart is an untracked position.
Prove paper and live are not the same code path with a flag. A mode switch that only changes an endpoint can still leave live credentials and real-money semantics in the paper configuration.
Test every transition on a disconnect mid-flight, including during amend and cancel, and assert reconciliation rather than resend.
Confirm position sizing cannot exceed available buying power or the configured cap, and that a sizing calculation failure halts rather than defaults to a size.
Verify the strategy is not active outside its intended session, and that a clock skew cannot make it trade in a closed market.
Assert idempotency on every order submission, with a client-generated key the broker honours, and a test that a duplicate submission does not create a second order.
Prove graceful degradation. On loss of market data, on stale quotes, or on a partial broker outage, the bot must stop opening risk rather than trade on what it has.
Confirm the kill switch is reachable independently of the strategy and the broker connection, and that it cancels open orders.
Backtest against out-of-sample data and walk-forward, and report the result with the period, the costs assumed, and the survivorship treatment. A strategy validated only in-sample has not been validated.