Build a Trading Bot

Define the target trading strategy (a simple moving average crossover on BTC/USDT) and write down explicit operational assumptions. Document what is intentionally out of scope for version 1, such as multi-exchange arbitrage, machine learning models, and high-frequency order book parsing.

Done when: a markdown file named SPEC.md exists containing target pair, timeframe, strategy rules, risk limits, and an explicit list of out-of-scope features.

Configure a reproducible Python environment using virtual environments and a dependency lockfile. Install foundational libraries including pandas, requests, and python-dotenv for managing sensitive API credentials securely.

Done when: running the verification script prints installed package versions without dependency conflicts and imports test environment variables successfully.

Create a minimal script that fetches a single current spot price from a public cryptocurrency REST endpoint and prints a mock order payload to standard output. This confirms basic connectivity and establishes the end-to-end flow before building complex components.

Done when: running python -m src.skeleton queries the live endpoint, parses the current price, and prints a formatted JSON mock order to the console.

Implement a Python module using ccxt or exchange REST endpoints to fetch historical OHLCV (Open, High, Low, Close, Volume) candle data with automated pagination handling. Save the raw batches into structured local storage.

Done when: the script downloads at least 180 days of 1-hour candles for BTC/USDT and writes them to a CSV or Parquet file without rate-limit errors.

Write a validation module that checks historical data for missing intervals, duplicated timestamps, zero volumes, and misordered records. Impute or forward-fill minor gaps and log validation warnings.

Done when: automated test assertions pass on a dirty sample dataset, correctly catching missing timestamps and producing a clean, contiguous DataFrame.

Build pure Python/Pandas functions for calculating Simple Moving Average (SMA), Exponential Moving Average (EMA), and Average True Range (ATR) without external black-box libraries. Verify math against reference values.

Done when: unit tests verify the indicator output matches standard reference calculations to within 4 decimal places.

Develop a stateful SignalGenerator class that consumes cleaned price candles and outputs explicit BUY, SELL, or HOLD signals. Enforce strict candle-closing rules so signals only execute on closed bars, preventing lookahead bias.

Done when: unit tests confirm that signal generation on candle N uses only data up to candle N-1 and outputs the expected state transitions.

Build an event-driven backtesting engine that iterates bar-by-bar through historical data, passing candle events to the strategy, generating order events, and resolving fill events against subsequent bar prices.

Done when: the backtester executes across 6 months of historical data bar-by-bar and returns a complete list of simulated trade records.

Extend the execution simulator to deduct maker/taker exchange fees and apply a parameterized slippage model based on market volatility. Re-run simulations to evaluate cost impact.

Done when: backtest trade logs show exchange fees deducted from account equity on every fill and fill prices reflect realistic slippage adjustments.

Write a performance calculation module that computes Sharpe ratio, maximum drawdown, win rate, profit factor, and total returns from the trade equity curve. Generate a concise console summary.

Done when: running the metrics module on backtest outputs outputs a formatted performance summary including Sharpe ratio, max drawdown percentage, and win rate.

Implement a PositionSizer class using fixed-fractional and ATR-based risk sizing (e.g. risking no more than 1% of equity per trade). Calculate order quantities dynamically based on stop-loss distance.

Done when: unit tests confirm position size scales down as market volatility increases and never exceeds the maximum allocated equity percentage.

Build an independent RiskManager component that intercepts orders before dispatch. Enforce hard limits: daily maximum loss threshold, max open positions, and a kill-switch that closes all positions if drawdown hits a predefined ceiling.

Done when: simulated test orders exceeding risk bounds are blocked with explicit logged rejection reasons.

Implement an exchange client using CCXT or direct REST APIs configured specifically for Binance Spot Testnet or Bybit Testnet. Implement limit and market order placement with signature authentication.

Done when: a standalone test script successfully authenticates, places a testnet limit order, queries order status, and cancels it.

Develop an asynchronous WebSocket client to ingest real-time trades and candle closes. Include automatic reconnection, ping/pong heartbeat tracking, and message schema validation.

Done when: the WebSocket client runs continuously for 30 minutes without dropping data and recovers automatically within 5 seconds of an intentional disconnect.

Build an OrderTracker that reconciles internal bot state with exchange fill reports. Handle partial fills, rejected orders, and network timeout ambiguities.

Done when: simulating a partial fill and subsequent fill correctly updates the bot's internal balance and position tracker without orphaned records.

Integrate data streaming, signal generation, risk checking, and execution tracking into a unified orchestrator application. Implement graceful shutdown handling on POSIX signals.

Done when: the integrated bot boots cleanly, connects to market streams, evaluates signals, and shuts down safely on SIGINT without leaving orphaned orders.

Configure structured JSON file logging for telemetry and implement a lightweight alerting client to send real-time notifications for trades, errors, and risk events to a Discord or Telegram webhook.

Done when: triggering a simulated trade or error outputs a structured log line and posts a formatted message to your alerting channel.

Write a Dockerfile and docker-compose specification for the bot. Deploy the container to an inexpensive virtual private server (e.g. DigitalOcean, Hetzner, or AWS EC2) with restart policies enabled.

Done when: the bot runs inside a Docker container on the remote server and restarts automatically across simulated service reboots.

Run the bot autonomously on the testnet for 7 consecutive days. Monitor log streams, verify heartbeat alerts, and record any execution anomalies or network disconnects.

Done when: the bot completes 7 uninterrupted days of live paper trading with zero unhandled exceptions and logs all market signals.

Extract the trade log from the 7-day paper trial, compare actual fill performance against backtest expectations, and write a summary report detailing execution fidelity, slippage observed, and operational learnings.

Done when: a PERFORMANCE_REPORT.md is committed to the repository summarizing total trades, realized PnL, slippage analysis, and notes on strategy behavior.