Bollinger-Keltner Squeeze Breakout Trading Strategy with ATR Trailing Stops

This article describes a professional trading strategy implemented in Backtrader that identifies low-volatility “squeeze” periods using Bollinger Bands and Keltner Channels, trading breakouts with momentum confirmation and managing risk with ATR-based trailing stops.

Strategy Overview

The Bollinger-Keltner Squeeze Breakout Trading Strategy integrates the following components:

• Custom Keltner Channels: Defines a volatility channel using a 30-day Simple Moving Average (SMA) and 1.0 times the Average True Range (ATR) to set upper and lower bands.
• Bollinger Bands: Uses a 7-day period with a 1.0 standard deviation factor to identify tight price ranges indicative of low volatility.
• Squeeze Detection: Identifies a squeeze when Bollinger Bands are inside Keltner Channels, signaling low volatility and potential for a breakout.
• MACD Confirmation: Uses a MACD with 7-day fast, 30-day slow, and 14-day signal periods to confirm bullish or bearish momentum during breakouts.
• ATR Trailing Stops: Sets dynamic stop-loss levels using a 7-day ATR multiplied by 3.0, updated based on the highest/lowest price since entry for long/short positions.
• Position Management: Ensures no new trades are placed when an order is pending, maintaining disciplined execution.

Code Implementation

Below is the complete Backtrader code for the strategy, including the custom Keltner Channel indicator:

import backtrader as bt

class CustomKeltnerChannel(bt.Indicator):
    """A custom implementation of Keltner Channels."""
    alias = ('KeltnerChannel',)
    lines = ('mid', 'top', 'bot',)
    plotinfo = dict(subplot=False)
    params = (
        ('period', 20),
        ('devfactor', 1.5), # Multiplier for the ATR
        ('movav', bt.indicators.SimpleMovingAverage),
    )

    def __init__(self):
        self.lines.mid = self.p.movav(self.data, period=self.p.period)
        atr = self.p.devfactor * bt.indicators.AverageTrueRange(self.data, period=self.p.period)
        self.lines.top = self.lines.mid + atr
        self.lines.bot = self.lines.mid - atr

class SqueezeBreakoutStrategy(bt.Strategy):
    """
    A professional strategy that trades breakouts from periods of
    low-volatility consolidation (a "squeeze").
    """
    params = (
        # Squeeze detection
        ('bb_period', 7),
        ('bb_devfactor', 1.0),
        ('kc_period', 30),
        ('kc_devfactor', 1.0),
        # Momentum confirmation
        ('macd_fast', 7),
        ('macd_slow', 30),
        ('macd_signal', 14),
        # Risk management
        ('atr_period', 7),
        ('atr_stop_multiplier', 3.0),
    )

    def __init__(self):
        self.order = None

        # --- Indicators ---
        self.bband = bt.indicators.BollingerBands(period=self.p.bb_period, devfactor=self.p.bb_devfactor)
        self.keltner = CustomKeltnerChannel(period=self.p.kc_period, devfactor=self.p.kc_devfactor)
        
        # MACD
        self.macd = bt.indicators.MACD(
            period_me1=self.p.macd_fast,
            period_me2=self.p.macd_slow,
            period_signal=self.p.macd_signal
        )
        self.atr = bt.indicators.AverageTrueRange(period=self.p.atr_period)

        # --- Trailing Stop State Variables ---
        self.stop_price = None
        self.highest_price_since_entry = None
        self.lowest_price_since_entry = None

    def notify_order(self, order):
        if order.status in [order.Submitted, order.Accepted]: 
            return
        if order.status in [order.Completed]:
            if self.position and self.stop_price is None:
                if order.isbuy():
                    self.highest_price_since_entry = self.data.high[0]
                    self.stop_price = self.highest_price_since_entry - (self.atr[0] * self.p.atr_stop_multiplier)
                elif order.issell():
                    self.lowest_price_since_entry = self.data.low[0]
                    self.stop_price = self.lowest_price_since_entry + (self.atr[0] * self.p.atr_stop_multiplier)
            elif not self.position:
                self.stop_price = None
                self.highest_price_since_entry = None
                self.lowest_price_since_entry = None
        self.order = None

    def next(self):
        if self.order: 
            return

        # --- Squeeze Identification ---
        is_squeeze = (self.bband.top < self.keltner.top and self.bband.bot > self.keltner.bot)
        
        if not self.position and is_squeeze:
            # --- Breakout and Momentum Confirmation ---
            price_breaks_up = self.data.close[0] > self.bband.top[0]
            price_breaks_down = self.data.close[0] < self.bband.bot[0]
            
            macd_is_bullish = self.macd.macd[0] > self.macd.signal[0]
            macd_is_bearish = self.macd.macd[0] < self.macd.signal[0]

            if price_breaks_up and macd_is_bullish:
                self.order = self.buy()
            elif price_breaks_down and macd_is_bearish:
                self.order = self.sell()
                
        elif self.position:
            # --- Manual ATR Trailing Stop Logic ---
            if self.position.size > 0: # Long
                self.highest_price_since_entry = max(self.highest_price_since_entry, self.data.high[0])
                new_stop = self.highest_price_since_entry - (self.atr[0] * self.p.atr_stop_multiplier)
                self.stop_price = max(self.stop_price, new_stop)
                if self.data.close[0] < self.stop_price: 
                    self.order = self.close()
            elif self.position.size < 0: # Short
                self.lowest_price_since_entry = min(self.lowest_price_since_entry, self.data.low[0])
                new_stop = self.lowest_price_since_entry + (self.atr[0] * self.p.atr_stop_multiplier)
                self.stop_price = min(self.stop_price, new_stop)
                if self.data.close[0] > self.stop_price: 
                    self.order = self.close()

Strategy Explanation

1. CustomKeltnerChannel Indicator

The custom Keltner Channel indicator defines a volatility-based channel:

• Components:
  • Mid Line: A 30-day Simple Moving Average (SMA) of the closing price.
  • Upper and Lower Bands: Calculated as the mid line plus/minus 1.0 times the 30-day ATR.
• Plotting: Displayed on the main price chart for visualization.

2. SqueezeBreakoutStrategy

The strategy identifies low-volatility squeezes and trades breakouts with momentum confirmation:

• Indicators:

  • Bollinger Bands: Uses a 7-day period with a 1.0 standard deviation factor to detect tight price ranges.
  • Keltner Channels: Uses a 30-day period with a 1.0 ATR multiplier to define a broader volatility channel.
  • MACD: Combines 7-day fast, 30-day slow, and 14-day signal periods to confirm momentum (bullish when MACD line is above signal, bearish when below).
  • ATR: A 7-day Average True Range for setting trailing stop levels.

• Trading Logic (next):

  • Pending Order Check: Skips trading if an order is pending to avoid overlapping trades.
  • Squeeze Detection: Identifies a squeeze when the Bollinger Bands are inside the Keltner Channels (upper Bollinger Band below upper Keltner, lower Bollinger Band above lower Keltner).
  • Entry Conditions:
    • Bullish Entry: Enters a buy order if the price closes above the upper Bollinger Band and the MACD line is above the signal line during a squeeze.
    • Bearish Entry: Enters a sell order if the price closes below the lower Bollinger Band and the MACD line is below the signal line during a squeeze.
  • Trailing Stop Logic:
    • For long positions: Updates the stop to the highest price since entry minus 3 times the ATR, ensuring the stop moves up with favorable price action. Exits if the price falls below the stop.
    • For short positions: Updates the stop to the lowest price since entry plus 3 times the ATR, ensuring the stop moves down with favorable price action. Exits if the price rises above the stop.
  • Position Check: Only enters trades if no position is currently held, ensuring one trade at a time.

• Order Management (notify_order):

  • Ignores submitted or accepted orders, resetting the order tracker when completed.
  • Sets the initial trailing stop upon trade execution:
    • For long positions: Sets stop as the entry high minus 3 times ATR.
    • For short positions: Sets stop as the entry low plus 3 times ATR.
  • Resets stop and price tracking variables when the position is closed.

Key Features

• Squeeze Detection: Combines Bollinger Bands and Keltner Channels to identify low-volatility periods, targeting breakouts with high potential for significant moves.
• Momentum Confirmation: Uses MACD to ensure breakout trades align with strong bullish or bearish momentum, reducing false signals.
• ATR Trailing Stops: Dynamically adjusts stop-loss levels based on volatility, protecting profits while allowing trades to follow trends.
• Disciplined Execution: Prevents multiple simultaneous positions or overlapping orders, maintaining clear trade logic.
• Custom Keltner Channels: Implements a tailored Keltner Channel indicator for precise volatility measurement.

## Potential Improvements

• Parameter Tuning: Adjust bb_period, kc_period, macd_fast, macd_slow, macd_signal, or atr_stop_multiplier to optimize for specific assets or market conditions.
• Additional Filters: Incorporate volume or other trend indicators (e.g., ADX) to further confirm breakout signals.
• Fixed Stop-Loss: Add a fixed stop-loss alongside trailing stops for additional risk control.
• Performance Metrics: Include analyzers for returns, Sharpe ratio, drawdown, and trade statistics to evaluate strategy effectiveness.
• Multi-Asset Testing: Apply the strategy to multiple assets to assess performance across different markets.

This strategy is designed for markets with periodic low-volatility consolidations followed by strong breakouts, suitable for assets like forex, stocks, or cryptocurrencies, and can be backtested to evaluate its effectiveness across various timeframes and assets.