Dynamic Position Sizing Algorithm Development

Faced with the fact that a fixed lot in a trading strategy yields unstable results: risks skyrocket during high volatility, and you miss out on profits when volatility is low. In practice, traders often lose up to 40% of their capital due to improper position sizing. We solve this problem algorithmically—by developing a dynamic calculation of position size that adapts to market conditions and portfolio state. It's based on mathematical methods proven in production across thousands of trades. The risk reduction can save up to 30% compared to a fixed lot size. Contact us for a preliminary assessment of your task.

How the Dynamic Position Sizing Algorithm Solves the Instability Problem

Do not confuse this with manual lot resizing—the algorithm itself calculates the optimal size for each entry. We account for risk per trade (typically 1–2% of capital), current volatility via ATR, portfolio drawdown, and correlation with open positions. The final size is a composition of several filters.

Fixed Fractional (Kelly-inspired)

The base approach: risk a fixed percentage of capital on each trade.

def fixed_fractional_size(capital, risk_pct, entry_price, stop_price): risk_amount = capital * risk_pct risk_per_unit = abs(entry_price - stop_price) qty = risk_amount / risk_per_unit return qty 

Standard risk_pct: 1–2% per trade. After 20 consecutive losing trades: loss = (0.98)^20 = 33% of capital. Manageable.

Volatility-adjusted sizing

Position size is inversely proportional to volatility: the more volatile the market, the smaller the position.

def volatility_adjusted_size(capital, target_risk_pct, atr, entry_price, atr_multiplier=2.0): risk_amount = capital * target_risk_pct stop_distance = atr * atr_multiplier # stop at 2×ATR position_value = risk_amount / (stop_distance / entry_price) return position_value / entry_price # in units of asset 

When ATR = 3% → stop 6% → position X. When ATR = 1% → stop 2% → position 3X. Result: equal monetary risk across different volatility levels.

Kelly Criterion

The mathematically optimal position size to maximize long-term capital growth, first described by John Kelly in 1956:

Kelly % = W - (1-W)/R where W = win rate, R = average win/average loss 

With W=55%, R=1.5: Kelly = 0.55 - 0.45/1.5 = 0.25 = 25% of capital. This is too aggressive. Usually Half Kelly (12.5%) or Quarter Kelly is used. Full Kelly leads to huge drawdowns despite theoretical optimality.

Drawdown-based scaling

As we approach the maximum drawdown, we reduce position sizes:

def drawdown_scaled_size(base_size, current_equity, peak_equity, max_drawdown=0.20): current_dd = (peak_equity - current_equity) / peak_equity if current_dd > max_drawdown * 0.75: # At 75% of max drawdown — reduce to 50% size return base_size * 0.5 elif current_dd > max_drawdown * 0.5: # At 50% of max drawdown — reduce to 75% size return base_size * 0.75 return base_size 

Correlation adjustment

If the portfolio already holds several correlated positions, adding a new one provides less diversification. The new position size is reduced proportionally to correlation:

def correlation_adjusted_size(base_size, correlation_with_portfolio): # If correlation is 0.8 — reduce size to 20% of base diversity_factor = 1 - abs(correlation_with_portfolio) return base_size * max(diversity_factor, 0.2) # minimum 20% 

Why a Combination of Methods Gives the Best Result

No single method is perfect. Fixed Fractional does not adapt to volatility, Kelly is aggressive, and Volatility-adjusted depends on ATR accuracy. A hybrid approach combines strengths: base risk taken from Fixed Fractional, then adjusted for volatility, drawdown, and correlation. In our tests, the hybrid reduces maximum drawdown by a factor of 2 compared to pure Fixed Fractional while maintaining the same returns.

How We Implement the Algorithm

Our stack: Python (NumPy, Pandas for backtesting) + integration via REST API of your platform (MetaTrader, Binance, Bybit, Custom). Configuration is flexible: you can enable/disable any module. Code undergoes leak testing (static Python analysis).

Example: Hybrid Sizing

Suppose a trader uses Fixed Fractional with 1.5% risk and Kelly on backtest suggests 20%. We combine: base risk = 1.5% * 0.5 (Half Kelly) = 0.75%, then adjust for volatility: if ATR = 2%, stop 4% → position = 0.75% / (4%/current price). The output is a single module with a unified API: calculate_size(capital, volatility, correlation, drawdown). Get a consultation on implementing such a hybrid for your strategy.

Typical Mistakes When Choosing a Method

Process Overview

1. Analytics — we study your strategy, trade history, risk parameters.
2. Design — select method combination, write specification.
3. Implementation — develop module in Python or Solidity/Rust.
4. Testing — backtest on history + forward test, adjust parameters.
5. Deployment — integrate with your platform, documentation, training.

What's Included

• Source code of the sizing module (Python or Solidity).
• Configuration file with parameters.
• Documentation for integration and configuration.
• Access to a private Git repository.
• 2 weeks of support after handover.

Timeline and Estimation

Development time: from 2 to 4 weeks, depending on the complexity of the method combination. To get an estimate for your project, contact us for a free analysis of your strategy and proposed approach.