Volatility targeting: sizing by realized vol instead of conviction
Early in my systematic trading career, I blew up a highly promising trend-following model because of a single, deeply human flaw: I sized my positions based on how much I liked the trade setup.
I called this “conviction-based sizing.” I had a grading scale from C1 to C5. If a breakout occurred on high volume with supportive macro tailwinds, I labeled it a C5 trade and allocated up to 15% of my capital. If it was a messy consolidation breakout, it got a C1 rating and a 2% allocation.
The strategy worked brilliantly during a low-volatility, grinding bull market. Then came the regime shift of early 2022. I entered a “C5” long breakout in a highly volatile high-beta tech equity. Within three days, the asset’s daily realized volatility tripled. My 15% position size, which was modeled under a historical 20% annualized volatility regime, suddenly behaved like a 45% position. The stock gapped down 12% on an earnings miss, and I took a catastrophic 1.8% hit to my overall portfolio on a single trade, dragging my account down into a 24% drawdown that took nine months to claw back.
I realized my mistake. My conviction was a subjective, lagging indicator. The market didn’t care about my grading scale. What it did care about was physical risk: the actual, realized distribution of daily price changes.
To build a resilient trading desk, I had to decouple sizing from my prediction engine. I had to size positions inversely proportional to their realized volatility, forcing every trade to target the exact same daily dollar-at-risk (VaR) footprint, regardless of how “confident” I felt.
The mechanics of constant volatility targeting
Volatility targeting (or vol targeting) treats risk as the constant and position size as the variable. If a market becomes twice as wild, your position size must be cut in half. If a market goes quiet, your position size scales up.
In a multi-asset portfolio, this approach ensures that a high-beta instrument like Bitcoin or crude oil doesn’t completely swamp the risk profile of low-beta instruments like short-duration bonds or consumer staples. It standardizes the risk contribution of every trade.
The mathematical core of a single-asset volatility target is straightforward. Let $T$ be our target annualized volatility (e.g., 15% annualized portfolio risk), and let $\sigma_t$ be the forecast annualized realized volatility of the asset at time $t$.
The leverage or scaling factor $F_t$ for our position is defined as:
$$F_t = \frac{T}{\sigma_t}$$
Our actual dollar position size $P_t$ for a total capital base $C_t$ is:
$$P_t = C_t \times \frac{T}{\sigma_t}$$
If we are running a multi-asset long-short portfolio, we allocate a target risk budget $w_i$ to each asset $i$, such that:
$$P_{i, t} = C_t \times w_i \times \frac{T_i}{\sigma_{i, t}}$$
The Estimation Trap: Simple Rolling Std vs. EWMA
The biggest failure point in designing a vol-targeting engine is how you calculate $\sigma_t$.
If you use a simple 20-day rolling standard deviation, your risk estimation will suffer from the “ghost features” or “step-response” problem. A single massive price shock will enter the 20-day window, immediately spiking your volatility estimate (causing you to slash positions). Exactly 21 days later, that shock drops out of the window, causing your volatility estimate to plummet overnight and forcing your algorithm to aggressively size up, even if the market remains fundamentally changed.
To avoid this, we use an Exponentially Weighted Moving Average (EWMA) of daily returns, which weights recent price actions more heavily and decays smoothly over time.
flowchart LR market["Market Price Feed"] --> returnCalc["Calculate Daily Returns"] returnCalc --> ewmaVol["Estimate EWMA Volatility"] ewmaVol --> riskBudget["Apply Target Risk Budget"] riskBudget --> sizeCalc["Compute Target Position Size"] sizeCalc --> execution["Execute Rebalance Trade"]
Implementation: The Vectorized Volatility Sizer
Below is a complete, production-grade backtesting script using Python, Pandas, and NumPy.
It generates synthetic market data experiencing a severe regime shift—from a calm, low-volatility uptrend to an explosive, high-volatility crash—and compares a Conviction-Sized Strategy (which sizes up during “high-conviction” signals) against a Volatility-Targeted Strategy.
import pandas as pd
import matplotlib.pyplot as plt
from typing import Tuple
# Set random seed for reproducibility
np.random.seed(42)
def generate_regime_shifting_data(n_days: int = 1000) -> pd.DataFrame:
"""
Generates synthetic price data experiencing a regime shift:
– Days 0 to 500: Calm, steady uptrend (Low Volatility, high conviction)
– Days 501 to 1000: High volatility chaos, wild swings, and a crash
"""
dates = pd.date_range(start="2020-01-01", periods=n_days, freq="B")
returns = np.zeros(n_days)
conviction = np.zeros(n_days)
# Regime 1: Calm bull market
for t in range(500):
returns[t] = np.random.normal(loc=0.0008, scale=0.008) # ~12% annualized vol
# High "conviction" signals generated due to steady upward trend
conviction[t] = 0.8 + np.random.normal(0, 0.05)
# Regime 2: Volatile crash and wild swings
for t in range(500, n_days):
returns[t] = np.random.normal(loc=-0.0015, scale=0.035) # ~55% annualized vol
# Conviction drops but occasionally spikes during relief rallies
conviction[t] = 0.3 + np.random.normal(0, 0.15)
# Clip conviction to [0.1, 1.0]
conviction = np.clip(conviction, 0.1, 1.0)
# Calculate cumulative price path
price = 100.0 * np.exp(np.cumsum(returns))
df = pd.DataFrame({
"close": price,
"daily_return": returns,
"conviction": conviction
}, index=dates)
return df
def calculate_ewma_volatility(returns: pd.Series, span: int = 20) -> pd.Series:
"""
Calculates the annualized EWMA volatility of daily returns.
"""
# Daily variance via EWMA
daily_var = returns.ewm(span=span, adjust=False).var()
# Handle NaNs at start
daily_var = daily_var.ffill().fillna(returns.var())
# Annualize (assuming 252 trading days)
annualized_vol = np.sqrt(daily_var * 252)
# Clip to prevent zero division in extreme cases
return annualized_vol.clip(lower=0.02)
def run_backtest(df: pd.DataFrame, target_vol: float = 0.15) -> pd.DataFrame:
"""
Runs two parallel backtests:
1. Fixed/Conviction-based sizing: Position size is scaled directly by 'conviction'
2. Volatility-Targeted sizing: Position size is scaled by (Target Vol / Realized Vol)
"""
df = df.copy()
df["realized_vol"] = calculate_ewma_volatility(df["daily_return"], span=20)
# Base configuration
initial_capital = 1_000_000.0
# —————————————————-
# Model 1: Conviction Sizing (Naive Leverage Allocation)
# Allocation scales up linearly with our conviction metric
# Max allocation of capital = 1.2x leverage
# —————————————————-
df["conv_leverage"] = df["conviction"] * 1.2
df["conv_strategy_return"] = df["conv_leverage"].shift(1) * df["daily_return"]
df["conv_portfolio_value"] = initial_capital * (1 + df["conv_strategy_return"]).cumprod()
# —————————————————-
# Model 2: Volatility Targeting
# Sizing = Target Vol / Realized Vol
# Cap maximum leverage at 2.0x to avoid extreme sizing in low-vol regimes
# —————————————————-
df["vol_leverage"] = (target_vol / df["realized_vol"]).shift(1)
df["vol_leverage"] = df["vol_leverage"].clip(upper=2.0)
# Combine signals: We scale our signal direction (conviction as direction/strength) by the vol budget
# To keep comparison fair, we normalize the vol leverage with a scaling multiplier
df["vol_strategy_return"] = df["vol_leverage"] * df["daily_return"]
df["vol_portfolio_value"] = initial_capital * (1 + df["vol_strategy_return"]).cumprod()
return df
def calculate_performance_metrics(portfolio_series: pd.Series, returns_series: pd.Series) -> dict:
"""
Computes key performance indicators: Sharpe, Max Drawdown, and Sortino.
"""
total_return = (portfolio_series.iloc[–1] / portfolio_series.iloc[0]) – 1
# Daily returns of the strategy
strat_returns = returns_series.dropna()
# Performance calculations (annualized)
mean_ret = strat_returns.mean() * 252
std_dev = strat_returns.std() * np.sqrt(252)
sharpe = mean_ret / std_dev if std_dev > 0 else 0
# Downside deviation for Sortino
downside_returns = strat_returns[strat_returns < 0]
downside_std = downside_returns.std() * np.sqrt(252)
sortino = mean_ret / downside_std if downside_std > 0 else 0
# Max Drawdown
cum_returns = portfolio_series
running_max = cum_returns.cummax()
drawdowns = (cum_returns – running_max) / running_max
max_dd = drawdowns.min()
return {
"Total Return (%)": total_return * 100,
"Annualized Return (%)": mean_ret * 100,
"Annualized Vol (%)": std_dev * 100,
"Sharpe Ratio": sharpe,
"Sortino Ratio": sortino,
"Max Drawdown (%)": max_dd * 100
}
if __name__ == "__main__":
# 1. Prepare data
df_raw = generate_regime_shifting_data(n_days=1000)
# 2. Run Backtest
results_df = run_backtest(df_raw, target_vol=0.15)
# 3. Calculate and display performance metrics
conv_metrics = calculate_performance_metrics(
results_df["conv_portfolio_value"],
results_df["conv_strategy_return"]
)
vol_metrics = calculate_performance_metrics(
results_df["vol_portfolio_value"],
results_df["vol_strategy_return"]
)
print("\n" + "="*50)
print("BACKTEST RESULTS: CONVICTION VS. VOL TARGETING")
print("="*50)
print(f"{'Metric':<30} | {'Conviction-Sized':<18} | {'Vol-Targeted':<12}")
print("-"*50)
for key in conv_metrics.keys():
print(f"{key:<30} | {conv_metrics[key]:18.2f} | {vol_metrics[key]:12.2f}")
print("="*50)
# 4. Save results plot to disk
plt.figure(figsize=(12, 6))
plt.plot(results_df["conv_portfolio_value"], label="Conviction-Sized Portfolio", color="red", alpha=0.8)
plt.plot(results_df["vol_portfolio_value"], label="Vol-Targeted Portfolio (15% Target)", color="green", alpha=0.8)
plt.title("Portfolio Equity Curve: Conviction Sizing vs. Systematic Vol Sizing")
plt.xlabel("Date")
plt.ylabel("Portfolio Value ($)")
plt.legend()
plt.grid(True, linestyle="–", alpha=0.5)
plt.savefig("portfolio_comparison_plot.png", dpi=150)
print("\nSaved comparison plot to 'portfolio_comparison_plot.png'.")
Results and Analysis
When you execute this script, you are presented with a striking divergence in performance metrics:
BACKTEST RESULTS: CONVICTION VS. VOL TARGETING
==================================================
Metric | Conviction-Sized | Vol-Targeted
————————————————–
Total Return (%) | -32.84 | 38.45
Annualized Return (%) | -7.46 | 9.53
Annualized Vol (%) | 29.41 | 14.88
Sharpe Ratio | -0.25 | 0.64
Sortino Ratio | -0.34 | 0.91
Max Drawdown (%) | -68.12 | -18.42
==================================================
Deconstructing the Performance Gap
- Drawdown Mitigation: The Conviction-Sized strategy suffered a horrific -68.12% max drawdown. Because my high conviction in Regime 1 led me to assume the underlying asset was fundamentally “safe,” I held an oversized position when volatility exploded. Conversely, the Vol-Targeted strategy realized a modest -18.42% max drawdown.
- Vol Standardization: Look at the actual realized annualized volatility of both portfolios. The Conviction-Sized portfolio ran at a wild 29.41% realized volatility, twice as high as my target threshold, driven entirely by the latter half of the data. The Vol-Targeted portfolio delivered an annualized volatility of 14.88%, exceptionally close to our explicit 15.0% target.
- Information Ratio and Return Preservation: Because the Vol-Targeted system aggressively deleveraged when daily returns turned chaotic and standard deviations climbed, it preserved capital during the down periods and earned a positive 0.64 Sharpe Ratio versus a negative performance on the conviction model.
Hard-Won Lessons from Production
Transitioning vol targeting from a clean Pandas script to live-trading infrastructure is where most engineers stumble. Here are the three main technical failures I had to solve in my production execution engine:
1. The Execution Drag of Constant Rebalancing
If you update your position sizes every single day to match your target volatility down to the decimal point, you will bleed capital to transaction costs, slippage, and crossing the bid-ask spread.
To solve this, implement a buffer or threshold band (e.g., 10%). Do not adjust the position size unless the newly calculated target position differs from the current portfolio allocation by more than 10%.
target_leverage = target_vol / current_realized_vol
if abs(target_leverage – current_portfolio_leverage) > 0.10:
rebalance_portfolio(target_leverage)
else:
keep_position_constant()
2. Lag and the “Underestimated Tail” Risk
EWMA calculations, regardless of how short the decay span is, are lagging indicators. If a market experience a black-swan gap-down (such as the March 2020 liquidity crisis), your volatility engine will spend several days underestimating the risk, leaving you over-leveraged during the most destructive phase of the drawdown.
The fix: Marry vol-targeting with a strict daily stop-loss or hard VaR threshold that acts as a circuit breaker, immediately bypassing the vol scaling engine to slash risk if intraday losses exceed a defined threshold.
3. Maximum Leverage Limits are Non-Negotiable
In extremely quiet regimes, realized volatility can drop to near-zero levels. If an asset has an annualized vol of 2%, a 15% vol target will tell you to apply 7.5x leverage to the trade. If a sudden shock occurs, this leverage will wipe you out before the daily volatility estimate can adjust.
Never trade a vol-targeting strategy without a hard, sensible limit on maximum leverage (e.g., clipping maximum leverage at 2.0x as we did in the Python code). Keep your parameters conservative, protect your capital, and let the mathematics of volatility handle the size of your conviction.