Forem: Vinicius Chelles

Event-Driven Architecture for Crypto Trading Bots: A Practical Guide

Vinicius Chelles — Tue, 14 Apr 2026 12:02:47 +0000

Event-Driven Architecture for Crypto Trading Bots: A Practical Guide

Building a trading bot that reacts to market movements in real-time requires more than just a loop that checks prices every second. You need an event-driven architecture that can handle thousands of price updates, execute orders, and manage risk — all without missing a beat.

Here's how I built Lucromatic's event-driven core, and why it matters for your own trading bot.

The Problem with Polling

Most beginners start with something like this:

// Don't do this 😱
async function trade() {
  while (true) {
    const price = await getPrice('BTC/USDT');
    if (price < supportLevel) {
      await buy();
    }
    await sleep(1000);
  }
}

This approach has three fatal flaws:

Latency — By the time you check, the opportunity is gone
Race conditions — Multiple checks can trigger multiple orders
API limits — Polling every second hits rate limits fast

The solution? Event-driven architecture. Instead of asking "what's the price?", you listen for "the price changed."

The Event-Driven Core

Here's the architecture I use:

const { EventEmitter } = require('events');
class TradingEngine extends EventEmitter {
  constructor() {
    super();
    this.positions = new Map();
    this.orders = new Map();
    this.symbols = new Set();
  }

  // Price update from websocket
  async onPriceUpdate(symbol, price, volume) {
    this.emit('price', { symbol, price, volume, timestamp: Date.now() });

    // Check pending orders
    for (const [orderId, order] of this.orders) {
      if (this.shouldExecute(order, price)) {
        await this.executeOrder(order, price);
      }
    }
  }

  // Strategy signals
  onSignal(strategy, signal) {
    this.emit('signal', { strategy, ...signal });
  }

  // Risk checks before order execution
  async executeOrder(order, price) {
    if (!this.checkRisk(order, price)) {
      this.emit('risk_rejected', { order, price });
      return;
    }

    // Execute via exchange API
    const result = await this.executor.execute(order, price);
    this.emit('order_executed', result);
  }
}

The key components:

Event emitters — Price updates, signals, orders all flow through events
Async handlers — Non-blocking, can handle multiple symbols
Risk module — Validates every order before execution

Real-Time Data with Websockets

The polling example above checks prices every second. With websockets, you get pushed updates instantly:

const Binance = require('binance-api-node').default;

class WSPriceFeed {
  constructor(tradingEngine) {
    this.client = Binance();
    this.engine = tradingEngine;
  }

  start(symbols) {
    symbols.forEach(symbol => {
      this.client.ws.trade(symbol, trade => {
        this.engine.onPriceUpdate(
          symbol,
          parseFloat(trade.p),
          parseFloat(trade.q)
        );
      });
    });
  }
}

// Usage
const feed = new WSPriceFeed(engine);
feed.start(['BTC/USDT', 'ETH/USDT', 'SOL/USDT']);

This gives you real-time price updates as they happen — sub-second latency vs. 1+ second with polling.

Strategy as Event Listeners

Strategies are just event listeners:

class GridStrategy {
  constructor(engine, params) {
    this.engine = engine;
    this.gridLevels = params.levels || 10;
    this.gridSpacing = params.spacing || 0.5; // 0.5% between levels
  }

  start(symbol, basePrice) {
    // Create grid levels
    const levels = [];
    for (let i = 0; i < this.gridLevels; i++) {
      levels.push({
        price: basePrice * (1 - (i + 1) * this.gridSpacing / 100),
        side: 'BUY',
        filled: false
      });
      levels.push({
        price: basePrice * (1 + (i + 1) * this.gridSpacing / 100),
        side: 'SELL',
        filled: false
      });
    }

    // Listen for price events
    this.engine.on('price', async ({ symbol: s, price }) => {
      if (s !== symbol) return;

      for (const level of levels) {
        if (!level.filled && price <= level.price && level.side === 'BUY') {
          await this.engine.executeOrder({
            symbol,
            side: 'BUY',
            quantity: this.calculateQty(price)
          });
          level.filled = true;
        }
      }
    });
  }
}

Each strategy subscribes to price events and makes decisions independently. You can run multiple strategies on the same engine.

Handling Edge Cases

Trading bots need to handle failures gracefully:

class CircuitBreaker {
  constructor(maxFailures = 5, resetMs = 60000) {
    this.failures = 0;
    this.maxFailures = maxFailures;
    this.resetMs = resetMs;
    this.lastFailure = 0;
  }

  async execute(fn) {
    if (this.failures >= this.maxFailures) {
      const elapsed = Date.now() - this.lastFailure;
      if (elapsed < this.resetMs) {
        throw new Error('Circuit open');
      }
      this.failures = 0;
    }

    try {
      return await fn();
    } catch (err) {
      this.failures++;
      this.lastFailure = Date.now();
      throw err;
    }
  }
}

And position tracking:

class PositionManager {
  constructor(engine) {
    this.positions = new Map();
    this.engine = engine;
  }

  onOrderExecuted({ orderId, symbol, side, filled }) {
    const key = `${symbol}-${side}`;
    const pos = this.positions.get(key) || { symbol, side, qty: 0, avgPrice: 0 };

    const totalValue = pos.qty * pos.avgPrice + filled.qty * filled.price;
    pos.qty += filled.qty;
    pos.avgPrice = pos.qty > 0 ? totalValue / pos.qty : 0;

    this.positions.set(key, pos);
    this.engine.emit('position_update', pos);
  }

  getPosition(symbol) {
    return this.positions.get(symbol);
  }
}

Putting It All Together

The final架构 looks like this:

[WebSocket] ──> [Price Feed] ──> [Trading Engine] ──> [Strategies]
                    │                 │
                    │                 v
                    └──────────────> [Risk Manager]
                                      │
                                      v
                               [Exchange API]

Each component is independent, testable, and handles its own domain. The engine orchestrates, but doesn't know the details of any single part.

Results

With this architecture, Lucromatic handles:

50+ symbols concurrently without lagging
Sub-second order execution from signal to exchange
Built-in risk management on every order
Automatic reconnection on websocket disconnect

The key insight: trading is event-driven by nature. Your bot should be too.

I'm building Lucromatic, a self-hosted trading bot for Binance with 50+ indicators, grid trading, and futures support. Check the live demo to see it in action.

How I Built a Real-Time Trading Automation Engine with Node.js

Vinicius Chelles — Sun, 12 Apr 2026 01:51:33 +0000

How I Built a Real-Time Trading Automation Engine with Node.js

I once lost $2,400 in 15 minutes because my trading bot couldn't keep up with market moves. The REST API polling interval was too long, and by the time my bot detected a signal, the opportunity was gone. That moment made me realize: if you're building a trading automation system, polling is your enemy.

The Problem

When you're running a crypto trading operation, you need to monitor hundreds of trading pairs simultaneously. Price movements don't wait for your API rate limits. Binance alone offers over 400 trading pairs, and each one can move at any moment.

Traditional REST polling doesn't cut it. Here's why:

Latency: Even with 1-second intervals, you're always 1 second behind
Rate limits: The more pairs you monitor, the faster you hit API limits
Missed moves: High volatility periods means micro-movements happen between polls
Resource waste: Constant HTTP overhead for trivial price updates

I needed a solution that could handle 459 trading pairs in real-time without missing a single price tick.

The Solution

WebSocket connections changed everything. Instead of asking for price updates every second, I let the market push changes to me. Event-driven architecture made this possible.

Here's the core concept:

const WebSocket = require('ws');

class TradingStream {
  constructor() {
    this.ws = null;
    this.handlers = new Map();
    this.reconnectDelay = 1000;
  }

  connect(streams) {
    const streamList = streams.join('/');
    this.ws = new WebSocket(
      `wss://stream.binance.com:9443/ws/${streamList}`
    );

    this.ws.on('message', (data) => {
      const update = JSON.parse(data);
      this.handleUpdate(update);
    });

    this.ws.on('close', () => {
      setTimeout(() => this.connect(streams), this.reconnectDelay);
    });
  }

  handleUpdate(update) {
    const { s: symbol, p: price, P: percentChange } = update;

    // Emit event to registered handlers
    if (this.handlers.has(symbol)) {
      this.handlers.get(symbol).forEach(handler => handler({
        symbol,
        price: parseFloat(price),
        percentChange: parseFloat(percentChange),
        timestamp: Date.now()
      }));
    }
  }

  on(symbol, handler) {
    if (!this.handlers.has(symbol)) {
      this.handlers.set(symbol, []);
    }
    this.handlers.get(symbol).push(handler);
  }
}

This code connects to Binance's WebSocket stream and pushes price updates the moment they happen. No polling. No waiting. Just pure event-driven reactivity.

The Beholder Brain

Raw price data isn't enough. You need a brain that evaluates conditions in real-time. I call it the Beholder — it watches every price tick and executes your automations instantly.

Here's how the evaluation engine works:

class BeholderBrain {
  constructor(automations, stream) {
    this.automations = automations;
    this.stream = stream;
    this.state = new Map();
  }

  async evaluate(symbol, priceData) {
    const previousPrice = this.state.get(symbol)?.price;
    this.state.set(symbol, priceData);

    for (const automation of this.automations) {
      if (!automation.matchesSymbol(symbol)) continue;

      if (await automation.shouldTrigger(priceData, previousPrice)) {
        await automation.execute(priceData);
      }
    }
  }
}

Each automation is self-contained:

Entry automations: Trigger when a condition is met (e.g., RSI < 30)
Exit automations: Close positions based on your rules
Stop-loss automations: Execute immediately on adverse price movements

The beauty is that automations run in parallel. If you have 10 automations watching the same pair, all of them evaluate every price update. No polling loops, no sequential checks — just instant evaluation on every tick.

Real Results

After implementing this architecture, here's what changed:

459 pairs monitored simultaneously — Binance's full trading pair list
Latency dropped from 1s to ~50ms — WebSocket push vs. REST polling
Zero rate limit issues — No more HTTP overhead
Instant signal detection — Every price tick evaluated in real-time

The system processes thousands of price updates per second without breaking a sweat. Node.js handles the async nature of WebSocket connections beautifully, and the event-driven model scales horizontally when needed.

Why This Matters

If you're building any trading automation system, your architecture determines your ceiling. Polling-based systems will always be reactive — they catch up to what already happened. Event-driven systems are proactive — they see moves as they happen and can act instantly.

For crypto markets where milliseconds mean the difference between profit and loss, that distinction matters.

I am building Lucromatic, a self-hosted trading bot for Binance. Check the live demo: try.lucromatic.com