Risk Management

The Foundation of Profitable Trading

Risk management is not optional - it's the difference between long-term success and inevitable ruin. The best predictive models are worthless without proper risk controls.

Position-Level Risk Management

Maximum Position Size

Never allocate too much capital to a single position

• Fixed Percentage: Max 5-10% of portfolio per position
• Volatility-Adjusted: Higher vol = smaller position
• Correlation-Adjusted: Reduce size for correlated positions
• Liquidity-Based: Limit based on daily volume

Stop-Loss Orders

Automatic exit when losses reach predetermined threshold

class StopLossManager:
    def __init__(self, stop_pct=0.02):
        self.stop_pct = stop_pct  # 2% stop loss

    def set_stop_loss(self, entry_price, direction):
        """Calculate stop loss price"""
        if direction == 'long':
            return entry_price * (1 - self.stop_pct)
        else:  # short
            return entry_price * (1 + self.stop_pct)

    def check_stop(self, current_price, stop_price, direction):
        """Check if stop loss triggered"""
        if direction == 'long':
            return current_price <= stop_price
        else:
            return current_price >= stop_price

Trailing Stops

Lock in profits as position moves in your favor

• Adjusts stop level as price moves favorably
• Never moves against your position
• Protects unrealized gains

Portfolio-Level Risk

Value at Risk (VaR)

Maximum expected loss at given confidence level

def calculate_var(returns, confidence=0.95):
    """Calculate Value at Risk"""
    return np.percentile(returns, (1 - confidence) * 100)

# Example: 95% VaR = -2.5% daily loss
# Interpretation: 95% chance daily loss won't exceed 2.5%

Conditional VaR (CVaR)

Expected loss given that VaR threshold is exceeded

def calculate_cvar(returns, confidence=0.95):
    """Calculate Conditional VaR (Expected Shortfall)"""
    var = calculate_var(returns, confidence)
    return returns[returns <= var].mean()

# CVaR is always worse than VaR
# Accounts for tail risk beyond VaR threshold

Maximum Drawdown Control

• Monitor cumulative drawdown from peak
• Reduce position sizes during drawdowns
• Halt trading if max drawdown threshold reached
• Typical limit: 20-25% maximum drawdown

Leverage and Margin

Leverage Best Practices

• Start with no leverage until strategy proven
• Use modest leverage (1.5-2x) for tested strategies
• Monitor margin requirements daily
• Keep cash buffer for margin calls
• Reduce leverage during high volatility

def calculate_leverage_ratio(portfolio_value, gross_exposure):
    """Calculate current leverage"""
    return gross_exposure / portfolio_value

def max_safe_leverage(volatility, max_drawdown_tolerance=0.20):
    """Calculate maximum safe leverage given volatility"""
    # Higher volatility = lower safe leverage
    return max_drawdown_tolerance / (2 * volatility)

# Example: 15% annual vol → max 0.67x leverage for 20% drawdown limit

Diversification

Across Assets

• Don't concentrate in single stock/crypto
• Target 20-50 positions for equity strategies
• Cross-asset: stocks, bonds, commodities, FX

Across Strategies

• Combine momentum + mean reversion
• Mix timeframes: intraday + daily + weekly
• Different ML models: LSTM + XGBoost + RF

Correlation Management

def portfolio_diversification_ratio(weights, corr_matrix):
    """Measure portfolio diversification"""
    # Higher = more diversified
    weighted_vol = (weights @ corr_matrix @ weights) ** 0.5
    sum_vols = weights.sum()
    return sum_vols / weighted_vol

Circuit Breakers

Automated safety mechanisms that halt trading under adverse conditions

Common Circuit Breakers

• Daily Loss Limit: Stop if daily loss > $X or Y%
• Drawdown Limit: Pause if drawdown from peak > Z%
• Volatility Filter: Reduce exposure when vol spikes
• Correlation Break: Alert if correlations change dramatically
• Model Drift: Stop if model predictions degrade

class CircuitBreaker:
    def __init__(self, daily_loss_limit=0.05, max_drawdown=0.15):
        self.daily_loss_limit = daily_loss_limit
        self.max_drawdown = max_drawdown
        self.trading_enabled = True

    def check(self, daily_pnl, current_drawdown):
        """Check if circuit breakers triggered"""
        if daily_pnl < -self.daily_loss_limit:
            self.trading_enabled = False
            return "HALT: Daily loss limit exceeded"

        if current_drawdown < -self.max_drawdown:
            self.trading_enabled = False
            return "HALT: Maximum drawdown exceeded"

        return "OK"

Stress Testing

Test strategy performance under extreme market conditions

Historical Stress Scenarios

• 2008 Financial Crisis: -50% equity markets
• 2020 COVID Crash: -35% in one month
• 2010 Flash Crash: -10% in minutes
• 2015 CNY Devaluation: Emerging market selloff

Hypothetical Scenarios

• Interest rate shock: +200bps overnight
• Liquidity crisis: Bid-ask spreads 10x normal
• Black swan: 10-sigma move in major index
• Technology failure: Cannot trade for 24 hours

Risk Monitoring Dashboard

Real-time monitoring is essential for active risk management

Key Metrics to Monitor

• Current P&L (daily, weekly, monthly, YTD)
• Current drawdown from peak
• Portfolio beta and correlation to market
• Gross and net exposure
• Leverage ratio
• Largest positions (concentration risk)
• VaR and CVaR estimates
• Sharpe ratio (rolling window)