Drawdown Management Strategies for EAs

Drawdown is inevitable. How you manage it determines long-term survival.

Understanding Drawdown

Types of Drawdown:

1. Balance Drawdown: From peak balance to current balance
2. Equity Drawdown: From peak equity to current equity (includes floating)
3. Relative Drawdown: Percentage from peak
4. Absolute Drawdown: Dollar amount from initial deposit

The Recovery Problem:

Lesson: Preventing drawdown is easier than recovering.

Drawdown Monitoring System

Complete Drawdown Tracker:

class CDrawdownManager {
private:
    double m_initial_equity;
    double m_peak_equity;
    double m_current_drawdown;
    double m_max_allowed_drawdown;
    
    // Thresholds
    double m_reduce_risk_threshold;    // e.g., 10% DD = reduce risk
    double m_pause_trading_threshold;  // e.g., 20% DD = stop trading
    double m_close_all_threshold;      // e.g., 30% DD = close everything
    
    // Risk reduction
    double m_original_risk;
    double m_current_risk;
    
public:
    CDrawdownManager(double max_dd = 0.30, double base_risk = 0.02) {
        m_initial_equity = AccountInfoDouble(ACCOUNT_EQUITY);
        m_peak_equity = m_initial_equity;
        m_max_allowed_drawdown = max_dd;
        m_original_risk = base_risk;
        m_current_risk = base_risk;
        
        // Set thresholds
        m_reduce_risk_threshold = max_dd * 0.33;    // 10% if max is 30%
        m_pause_trading_threshold = max_dd * 0.67;  // 20% if max is 30%
        m_close_all_threshold = max_dd * 0.90;      // 27% if max is 30%
    }
    
    void Update() {
        double current_equity = AccountInfoDouble(ACCOUNT_EQUITY);
        
        // Update peak
        if(current_equity > m_peak_equity) {
            m_peak_equity = current_equity;
            ResetRiskLevel();  // Reset risk when making new highs
        }
        
        // Calculate current drawdown
        m_current_drawdown = (m_peak_equity - current_equity) / m_peak_equity;
        
        // Adjust risk based on drawdown
        AdjustRisk();
        
        // Check emergency levels
        CheckEmergencyLevels();
    }
    
    void AdjustRisk() {
        if(m_current_drawdown >= m_reduce_risk_threshold) {
            // Progressive risk reduction
            double reduction_factor = 1 - (m_current_drawdown / m_max_allowed_drawdown);
            m_current_risk = m_original_risk * MathMax(0.25, reduction_factor);
            
            Print("Risk reduced to ", DoubleToString(m_current_risk * 100, 2), "% due to drawdown");
        }
    }
    
    void ResetRiskLevel() {
        if(m_current_risk < m_original_risk) {
            // Gradually restore risk, not instantly
            m_current_risk = MathMin(m_original_risk, m_current_risk * 1.1);
        }
    }
    
    void CheckEmergencyLevels() {
        if(m_current_drawdown >= m_close_all_threshold) {
            Print("EMERGENCY: Closing all positions - drawdown limit");
            CloseAllPositions();
            StopTrading();
        } else if(m_current_drawdown >= m_pause_trading_threshold) {
            Print("WARNING: Trading paused due to drawdown");
            StopNewTrades();
        }
    }
    
    double GetAdjustedRisk() {
        return m_current_risk;
    }
    
    bool CanTrade() {
        return m_current_drawdown < m_pause_trading_threshold;
    }
    
    string GetStatus() {
        return StringFormat(
            "DD: %.2f%% | Peak: %.2f | Risk: %.2f%%",
            m_current_drawdown * 100,
            m_peak_equity,
            m_current_risk * 100
        );
    }
};

Recovery Strategies

Strategy 1: Gradual Risk Reduction

double GetRecoveryLotSize(double normal_lots, double current_dd) {
    // Reduce lots as drawdown increases
    if(current_dd < 0.05) return normal_lots;
    if(current_dd < 0.10) return normal_lots * 0.75;
    if(current_dd < 0.15) return normal_lots * 0.50;
    if(current_dd < 0.20) return normal_lots * 0.25;
    return normal_lots * 0.10;  // Minimum trading size
}

Strategy 2: Quality Filter Tightening

class CQualityFilter {
private:
    int m_base_confirmations_required;
    double m_base_min_rr;
    
public:
    int GetRequiredConfirmations(double drawdown) {
        // More confirmations needed when in drawdown
        if(drawdown < 0.05) return m_base_confirmations_required;
        if(drawdown < 0.10) return m_base_confirmations_required + 1;
        if(drawdown < 0.15) return m_base_confirmations_required + 2;
        return m_base_confirmations_required + 3;
    }
    
    double GetMinimumRR(double drawdown) {
        // Higher R:R required when recovering
        if(drawdown < 0.05) return m_base_min_rr;
        if(drawdown < 0.10) return m_base_min_rr * 1.25;
        if(drawdown < 0.15) return m_base_min_rr * 1.50;
        return m_base_min_rr * 2.0;
    }
};

Strategy 3: Time-Based Recovery

class CRecoveryScheduler {
private:
    datetime m_drawdown_start;
    double m_drawdown_at_start;
    int m_recovery_hours;
    
public:
    void EnterRecoveryMode(double current_dd) {
        m_drawdown_start = TimeCurrent();
        m_drawdown_at_start = current_dd;
        m_recovery_hours = CalculateRecoveryTime(current_dd);
        
        Print("Recovery mode: ", m_recovery_hours, " hours minimum");
    }
    
    int CalculateRecoveryTime(double dd) {
        // Larger drawdowns need longer recovery periods
        if(dd < 0.10) return 24;   // 1 day
        if(dd < 0.20) return 72;   // 3 days
        if(dd < 0.30) return 168;  // 1 week
        return 336;                 // 2 weeks
    }
    
    bool IsRecoveryPeriodOver() {
        int hours_passed = (int)((TimeCurrent() - m_drawdown_start) / 3600);
        return hours_passed >= m_recovery_hours;
    }
    
    double GetRecoveryProgress() {
        if(IsRecoveryPeriodOver()) return 1.0;
        int hours_passed = (int)((TimeCurrent() - m_drawdown_start) / 3600);
        return (double)hours_passed / m_recovery_hours;
    }
};

Circuit Breakers

Automatic Trading Stops:

class CCircuitBreaker {
private:
    int m_consecutive_losses;
    int m_max_consecutive_losses;
    double m_daily_loss;
    double m_max_daily_loss;
    int m_pause_minutes;
    datetime m_pause_until;
    
public:
    CCircuitBreaker(int max_losses = 3, double max_daily = 0.03) {
        m_max_consecutive_losses = max_losses;
        m_max_daily_loss = max_daily;
        m_pause_minutes = 60;
    }
    
    void OnTradeClose(double profit) {
        if(profit < 0) {
            m_consecutive_losses++;
            m_daily_loss += MathAbs(profit);
            
            if(m_consecutive_losses >= m_max_consecutive_losses) {
                TriggerBreaker("Consecutive losses limit");
            }
        } else {
            m_consecutive_losses = 0;  // Reset on win
        }
        
        if(m_daily_loss / AccountInfoDouble(ACCOUNT_EQUITY) >= m_max_daily_loss) {
            TriggerBreaker("Daily loss limit");
        }
    }
    
    void TriggerBreaker(string reason) {
        m_pause_until = TimeCurrent() + m_pause_minutes * 60;
        Print("Circuit breaker triggered: ", reason);
        Print("Trading paused until: ", TimeToString(m_pause_until));
        
        // Send alert
        SendNotification("EA Paused: " + reason);
    }
    
    bool IsTradingAllowed() {
        return TimeCurrent() > m_pause_until;
    }
    
    void OnNewDay() {
        m_daily_loss = 0;
        m_consecutive_losses = 0;
    }
};

Visualization and Alerts

Dashboard Display:

void DrawDrawdownPanel(double current_dd, double max_dd, double daily_dd) {
    string panel_name = "DD_Panel";
    
    // Background
    ObjectCreate(0, panel_name, OBJ_RECTANGLE_LABEL, 0, 0, 0);
    ObjectSetInteger(0, panel_name, OBJPROP_XDISTANCE, 10);
    ObjectSetInteger(0, panel_name, OBJPROP_YDISTANCE, 60);
    ObjectSetInteger(0, panel_name, OBJPROP_XSIZE, 200);
    ObjectSetInteger(0, panel_name, OBJPROP_YSIZE, 80);
    ObjectSetInteger(0, panel_name, OBJPROP_BGCOLOR, clrBlack);
    
    // Drawdown text
    color dd_color = current_dd < 0.10 ? clrGreen : 
                     current_dd < 0.20 ? clrYellow : clrRed;
    
    Comment(
        "\n",
        "═══ DRAWDOWN STATUS ═══\n",
        "Current DD: ", DoubleToString(current_dd * 100, 2), "%\n",
        "Daily DD: ", DoubleToString(daily_dd * 100, 2), "%\n",
        "Max Allowed: ", DoubleToString(max_dd * 100, 2), "%\n",
        "Status: ", current_dd < max_dd * 0.5 ? "SAFE" : "CAUTION"
    );
}

Our Drawdown Management Solutions

Viprasol builds EAs with:

• Multi-level drawdown protection
• Intelligent risk scaling
• Automatic circuit breakers
• Real-time monitoring dashboards

Need bulletproof risk management? Contact us for custom EA development.