Building a Cryptocurrency Trading Bot from Scratch: Chapter 1 - Handcrafting Strategies

Introduction

For years, I've been fascinated by quantitative trading, automated trading systems, and any programmatic approach to market transactions. While I've experimented with various techniques, I've yet to develop a comprehensive Python package or a continuously running trading platform.

This marks the beginning of my journey to document every step of creating a fully functional trading bot—from individual components to final integration. My approach involves manually developing each module before leveraging AI for system integration.

Core Technical Skills Inventory

Rule-Based Trading Systems

I can replicate functionality similar to stock screening tools like "PlayStock's Stock Selection Treasure Chest" using Python.

Supervised Learning Trading Models

Example: Training CNN neural networks to make buy/sell decisions by analyzing price chart patterns.

Reinforcement Learning Trading Systems

Defining simulated trading environments
Crafting reward functions
Implementing RL algorithms
GPU-accelerated training processes

Automated Trade Execution

Using GitHub Workflows/Render web services
Automated data collection
Predictive analytics
Order placement systems

Chapter 1: Strategy Development Framework

The Strategy Class Hierarchy

Base Strategy Parent Class (BaseStrategy)

from abc import ABC, abstractmethod
import pandas as pd

class BaseStrategy(ABC):
    def __init__(self, data: pd.DataFrame):
        self.data = data
        self.signals = pd.Series(index=self.data.index, dtype="object")

    @abstractmethod
    def generate_signals(self):
        """Child classes implement specific logic to populate signals ('buy','sell','hold')"""
        pass

    def get_signals(self) -> pd.Series:
        return self.signals

MACD Strategy Implementation

class MACDStrategy(BaseStrategy):
    def __init__(self, data: pd.DataFrame, fast=12, slow=26, signal=9):
        super().__init__(data)
        self.fast = fast
        self.slow = slow
        self.signal_period = signal

    def generate_signals(self):
        close = self.data['close']
        ema_fast = close.ewm(span=self.fast, adjust=False).mean()
        ema_slow = close.ewm(span=self.slow, adjust=False).mean()
        macd = ema_fast - ema_slow
        signal_line = macd.ewm(span=self.signal_period, adjust=False).mean()
        
        self.signals = pd.Series(index=self.data.index, dtype="object")
        self.signals[macd > signal_line] = 'buy'
        self.signals[macd < signal_line] = 'sell'
        self.signals[macd == signal_line] = 'hold'

RSI Strategy Implementation

class RSIStrategy(BaseStrategy):
    def __init__(self, data: pd.DataFrame, period=14, overbought=70, oversold=30):
        super().__init__(data)
        self.period = period
        self.overbought = overbought
        self.oversold = oversold

    def generate_signals(self):
        delta = self.data['close'].diff()
        gain = delta.where(delta > 0, 0)
        loss = -delta.where(delta < 0, 0)
        
        avg_gain = gain.rolling(self.period).mean()
        avg_loss = loss.rolling(self.period).mean()
        rs = avg_gain / avg_loss
        rsi = 100 - (100 / (1 + rs))
        
        self.signals = pd.Series(index=self.data.index, dtype="object")
        self.signals[rsi < self.oversold] = 'buy'
        self.signals[rsi > self.overbought] = 'sell'
        self.signals[(rsi >= self.oversold) & (rsi <= self.overbought)] = 'hold'

Practical Implementation

Data Preparation

import yfinance as yf
import datetime
import pandas as pd

df = yf.download("BTC-USD", start="2023-01-01", end=datetime.datetime.now())

Signal Generation

strategy = MACDStrategy(df)
strategy.generate_signals()
signals = strategy.get_signals()

Visualization

import matplotlib.pyplot as plt

close = df['close']
plt.figure(figsize=(14,7))
plt.plot(close.index, close, label='Close Price', color='black')

buy_signals = signals == 'buy'
plt.scatter(close.index[buy_signals], close[buy_signals], 
            marker='^', color='green', label='Buy Signal', s=100)

sell_signals = signals == 'sell'
plt.scatter(close.index[sell_signals], close[sell_signals], 
            marker='v', color='red', label='Sell Signal', s=100)

plt.title('Price Chart with Buy/Sell Signals')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.grid(True)
plt.show()

👉 Complete trading bot source code

FAQ Section

Q: Why develop strategies as separate classes?

A: Class-based implementation enables modular strategy development, making it easier to:

Add new strategies
Maintain existing ones
Combine multiple strategies

Q: How do I handle multiple cryptocurrencies?

A: The framework supports multi-asset analysis through proper data standardization. Simply ensure your DataFrame contains properly formatted price data.

Q: What's the best way to test strategies?

A: Implement comprehensive backtesting functionality before live deployment. This validates strategy effectiveness under historical market conditions.

Q: Can I combine MACD and RSI signals?

A: Absolutely! Create composite strategies that weigh signals from multiple indicators. This often produces more robust trading decisions.

👉 Advanced trading strategy resources

Next Steps

The subsequent chapters will cover:

Backtesting engine development
Risk management modules