Exponencial money management with profit only

[PTScalper]

Hi forex traders/scalpers,

as i mentioned several times on this forum about money management, when i scale only from profit, not my own money, you can check it out in these YouTube videos, which i have made from my small account directly for you

1.) Actual MT5 Mobile Forex Scalping: Why My Account is in RED (But Still Profitable)
https://youtu.be/razI_VohtOg

2.) Forex Scalping Reality Check: How I Moved to Risk-Free Trading
https://youtu.be/iAbKUrfLa4U

3.) Forex scalping quick update #daytrading #forexscalping #forex #forexcommunity #forextrader
https://youtube.com/shorts/aiKIxIz2kkc?feature=share

[PTScalper]

I found out that idea and money management after 15 years of my forex trading, when i blown more than 30 accounts in that process, but did not give up

Take a care and have a great trades

[PTScalper]

And here are two printscreens from my MT5 account, you can see there, that deposited capital is allready smaller than capital, which i withdraw, so right now i can scale risk free

[PTScalper]

Plus capital at that account is higher than 100% return, which is great for 2 weeks result

[LondonScalper]

as i mentioned several times on this forum about money management, when i scale only from profit, not my own money

Scaling from locked profit is one of the healthier mental models — it keeps “house money” from turning into careless size if you still treat that profit as real equity.

The failure mode I’ve watched: traders mentally label gains as casino chips and jump risk, then a normal drawdown clips both the profit and the original stake. Exponential curves look lovely on a whiteboard; live they need brakes.

Practical framing I prefer:

• Define a base risk that never needs “profit permission”
• Only step size on a schedule (e.g. after N closed green days), not mid-heat
• A drawdown step-down rule that is as automatic as the step-up

Videos of a small account compounding are educational; just remember path dependence — the same rules on a cold month feel very different.

How do you reset size after a give-back — immediately to baseline, or in stages?

[PTScalper]

as i mentioned several times on this forum about money management, when i scale only from profit, not my own money

Scaling from locked profit is one of the healthier mental models — it keeps “house money” from turning into careless size if you still treat that profit as real equity.

The failure mode I’ve watched: traders mentally label gains as casino chips and jump risk, then a normal drawdown clips both the profit and the original stake. Exponential curves look lovely on a whiteboard; live they need brakes.

Practical framing I prefer:

• Define a base risk that never needs “profit permission”
• Only step size on a schedule (e.g. after N closed green days), not mid-heat
• A drawdown step-down rule that is as automatic as the step-up

Videos of a small account compounding are educational; just remember path dependence — the same rules on a cold month feel very different.

How do you reset size after a give-back — immediately to baseline, or in stages?

HI LondonScalper,

I completely agree that treating "house money" as casino chips is a fatal flaw. I scale exclusively from locked profit because it mathematically insulates the initial baseline capital from the inevitable variance of the market.

Here is my approach to your practical framing and the give-back question:

Immediate Reset over Staged Step-Downs

To answer your question directly: I reset size immediately to baseline the moment my equity drops below the designated profit threshold.

Stepping down in stages is an illusion of control—it just bleeds the profit buffer while you are likely out of sync with the market's current microstructure or volatility. If a normal drawdown clips my "house money," I want to instantly slam the brakes back to my base risk. The goal is to aggressively protect the initial stake, not gently glide into a drawdown.

The Risk Expansion Budget

I don't treat profits as "free money." I treat them as a strictly defined risk expansion budget.

Base Risk (e.g., 1%): Strictly adhered to when trading the initial deposit. This is the baseline cost of doing business.

Scaled Risk (e.g., 2%): Only unlocked when equity hits a specific, locked threshold above the initial deposit.

By hard-coding this rule into your execution logic, you completely remove the emotional temptation to jump risk mid-heat. If the market gives you a buffer, you use that buffer to finance heavier size on premium setups. The moment the buffer is gone, the privilege of heavier size is revoked.

[PTScalper]

Pine Script: House Money Scaling Module

Here is a Pine Script v5 strategy template that hard-codes this exact money management model. It monitors the equity curve and dynamically toggles between Base Risk and Scaled Risk. Crucially, it features the immediate reset rule you asked about: if a trade pulls the equity back below the profit threshold, the script instantly reverts to the base risk for the next setup.

I’ve used a raw price action trigger (a simple inside bar breakout) rather than lagging indicators to trigger the entries, keeping the focus purely on the money management logic.

Code: Select all

//@version=5
strategy("House Money Risk Scaling", overlay=true, initial_capital=10000, commission_type=strategy.commission.cash_per_order, commission_value=3)

// =========================================================================
// INPUTS: MONEY MANAGEMENT
// =========================================================================
grp_mm = "Money Management"
baseRiskPct   = input.float(1.0, title="Base Risk (%)", step=0.1, group=grp_mm)
scaledRiskPct = input.float(2.0, title="Scaled Risk (%)", step=0.1, group=grp_mm)
profitBuffer  = input.float(10.0, title="Profit Threshold to Scale (%)", step=1.0, group=grp_mm, 
                              tooltip="How much account growth is required to unlock scaled risk.")

// =========================================================================
// INPUTS: TRADE PARAMETERS
// =========================================================================
grp_tr = "Trade Parameters"
slPoints = input.int(100, title="Stop Loss (Points)", group=grp_tr)
tpPoints = input.int(200, title="Take Profit (Points)", group=grp_tr)

// =========================================================================
// EQUITY MATH & RISK SIZING
// =========================================================================
initialCap = strategy.initial_capital
currentEq  = strategy.equity

// Calculate the equity threshold required to unlock "House Money" scaling
targetEq = initialCap * (1 + (profitBuffer / 100))

// IMMEDIATE RESET LOGIC: 
// If equity is above target, use Scaled Risk. If it dips below, instantly revert to Base Risk.
activeRiskPct = currentEq >= targetEq ? scaledRiskPct : baseRiskPct

// Position Sizing based on risk percentage and SL distance
riskAmount = currentEq * (activeRiskPct / 100)
pointValue = syminfo.pointvalue
qty        = riskAmount / (slPoints * syminfo.mintick * pointValue)

// =========================================================================
// RAW PRICE ACTION TRIGGER (Example: Inside Bar Breakout)
// =========================================================================
// Focus on raw structure, no lagging indicators.
isInsideBar = high < high[1] and low > low[1]

longCondition  = isInsideBar[1] and close > high[1]
shortCondition = isInsideBar[1] and close < low[1]

// =========================================================================
// EXECUTION
// =========================================================================
if longCondition and strategy.position_size == 0
    strategy.entry("Long", strategy.long, qty=qty)
    strategy.exit("Exit Long", "Long", loss=slPoints, profit=tpPoints)

if shortCondition and strategy.position_size == 0
    strategy.entry("Short", strategy.short, qty=qty)
    strategy.exit("Exit Short", "Short", loss=slPoints, profit=tpPoints)

// =========================================================================
// VISUALIZATION (Background highlights when trading with House Money)
// =========================================================================
bgcolor(currentEq >= targetEq ? color.new(color.green, 90) : na, title="House Money Active")

// Debug table to monitor equity and active risk on the chart
var table riskTable = table.new(position.top_right, 2, 2, border_width = 1)
if barstate.islast
    table.cell(riskTable, 0, 0, "Current Equity:", text_color=color.white, bgcolor=color.gray)
    table.cell(riskTable, 1, 0, str.tostring(currentEq, "#.##"), text_color=color.white, bgcolor=color.gray)
    table.cell(riskTable, 0, 1, "Active Risk:", text_color=color.white, bgcolor=currentEq >= targetEq ? color.green : color.blue)
    table.cell(riskTable, 1, 1, str.tostring(activeRiskPct) + "%", text_color=color.white, bgcolor=currentEq >= targetEq ? color.green : color.blue)

[PTScalper]

If market structure shifts and clips your profit buffer, stepping down incrementally just bleeds equity while your strategy is clearly out of phase with current volatility or order flow. The objective is absolute capital preservation. The moment equity drops back below the threshold (Initial Capital + $N Buffer), risk snaps back to base. You earn the right to scale; the market revokes it the second your edge softens.

Here is a production-grade Pine Script v5 implementation of this engine. I stripped out the basic indicators and built a modular risk function, paired with a raw liquidity sweep trigger (sweeping a fractal pivot and rejecting) to better reflect actual market microstructure.

Code: Select all

//@version=5
strategy("Dynamic Risk Scaling Engine", overlay=true, initial_capital=100000, commission_type=strategy.commission.cash_per_order, commission_value=2.5, slippage=1)

// =========================================================================
// MODULE: RISK & MONEY MANAGEMENT
// =========================================================================
grp_rm = "Risk Management Engine"
baseRiskPct   = input.float(0.5, title="Base Risk (%)", step=0.1, group=grp_rm, tooltip="Capital risk when below profit threshold.")
scaledRiskPct = input.float(1.5, title="Scaled Risk (%)", step=0.1, group=grp_rm, tooltip="Aggressive risk applied only to house money.")
profitBuffer  = input.float(5.0, title="Activation Threshold (%)", step=0.5, group=grp_rm, tooltip="Account growth required to unlock scaled risk.")
hardStopEq    = input.float(10.0, title="Max Drawdown Killswitch (%)", step=1.0, group=grp_rm)

// =========================================================================
// MODULE: TRADE PARAMETERS
// =========================================================================
grp_ex = "Execution Parameters"
slPoints = input.int(150, title="Stop Loss (Points)", group=grp_ex)
tpPoints = input.int(350, title="Take Profit (Points)", group=grp_ex)

// =========================================================================
// METHOD: DYNAMIC POSITION SIZING
// =========================================================================
f_calculate_qty(sl_pts) =>
    init_cap = strategy.initial_capital
    curr_eq  = strategy.equity
    
    // Killswitch Check
    if curr_eq <= (init_cap * (1 - (hardStopEq / 100)))
        strategy.close_all(comment="HARD STOP: DD LIMIT")
        0.0
    else
        // Immediate Reset Logic
        target_eq = init_cap * (1 + (profitBuffer / 100))
        active_risk = curr_eq >= target_eq ? scaledRiskPct : baseRiskPct
        
        // Size calculation accounting for instrument tick values
        risk_capital = curr_eq * (active_risk / 100)
        tick_value   = syminfo.pointvalue * syminfo.mintick
        pos_size     = risk_capital / (sl_pts * tick_value)
        
        // Return tuple for UI monitoring
        [pos_size, active_risk, target_eq]

[qty, currentRisk, requiredEq] = f_calculate_qty(slPoints)

// =========================================================================
// TRIGGER LOGIC: LIQUIDITY SWEEP (Microstructure Proxy)
// =========================================================================
// Detects a sweep of a 5-bar fractal high/low followed by an immediate structural rejection
lookback = 5
pivotHigh = ta.pivothigh(high, lookback, 1)
pivotLow  = ta.pivotlow(low, lookback, 1)

var float lastPivotHigh = na
var float lastPivotLow  = na

if not na(pivotHigh)
    lastPivotHigh := pivotHigh
if not na(pivotLow)
    lastPivotLow := pivotLow

// Sweep conditions: Wick pierces pivot, but body closes inside
sweepShort = high > lastPivotHigh and close < lastPivotHigh 
sweepLong  = low < lastPivotLow and close > lastPivotLow

// =========================================================================
// ORDER ROUTING
// =========================================================================
if sweepLong and strategy.position_size == 0 and qty > 0
    strategy.entry("Long", strategy.long, qty=qty)
    strategy.exit("Exit L", "Long", loss=slPoints, profit=tpPoints)

if sweepShort and strategy.position_size == 0 and qty > 0
    strategy.entry("Short", strategy.short, qty=qty)
    strategy.exit("Exit S", "Short", loss=slPoints, profit=tpPoints)

// =========================================================================
// HUD / TELEMETRY
// =========================================================================
var table hud = table.new(position.bottom_right, 2, 3, border_width=1, border_color=color.new(color.gray, 50))

if barstate.islast
    isScaled = strategy.equity >= requiredEq
    stateColor = isScaled ? color.new(color.teal, 30) : color.new(color.gray, 50)
    
    table.cell(hud, 0, 0, "Equity:", text_color=color.white, bgcolor=color.black)
    table.cell(hud, 1, 0, str.tostring(strategy.equity, "#.##"), text_color=color.white, bgcolor=color.black)
    
    table.cell(hud, 0, 1, "Status:", text_color=color.white, bgcolor=stateColor)
    table.cell(hud, 1, 1, isScaled ? "SCALED (House Money)" : "BASE (Capital Pres.)", text_color=color.white, bgcolor=stateColor)
    
    table.cell(hud, 0, 2, "Active Risk:", text_color=color.white, bgcolor=stateColor)
    table.cell(hud, 1, 2, str.tostring(currentRisk) + "%", text_color=color.white, bgcolor=stateColor)

[PTScalper]

Translating this engine to MetaTrader requires bridging the gap between TradingView's constant chart history and MetaTrader’s live, tick-by-tick environment.

Two critical architectural changes are necessary for production environments:

Reference Balance Input: A terminal reboot would normally reset the EA's memory of your "Initial Capital." I have added a ReferenceBalance input. You hard-code your starting baseline here so the EA always knows exactly where the drawdown or profit threshold is, regardless of VPS restarts.

Bar-Close Execution: To match the Pine Script logic and prevent intra-bar repainting (where a wick temporarily looks like a sweep before the close), the logic is wrapped in a new-bar detection function. It only evaluates the sweep on a confirmed candle close.

Here are the strict translations for both MT4 and MT5.

[PTScalper]

MetaTrader 4 (MQL4) Implementation

Code: Select all

//+------------------------------------------------------------------+
//|                                        HouseMoney_Engine_MT4.mq4 |
//+------------------------------------------------------------------+
#property strict

// --- Risk Management Engine ---
input double InpReferenceBalance = 100000.0; // Reference Baseline (0 = use current balance)
input double InpBaseRiskPct      = 0.5;      // Base Risk (%)
input double InpScaledRiskPct    = 1.5;      // Scaled Risk (%)
input double InpProfitBuffer     = 5.0;      // Activation Threshold (%)
input double InpHardStopEq       = 10.0;     // Max Drawdown Killswitch (%)

// --- Execution Parameters ---
input int    InpSLPoints         = 150;      // Stop Loss (Points)
input int    InpTPPoints         = 350;      // Take Profit (Points)
input int    InpMagicNumber      = 77777;    // Magic Number

double initBalance;
datetime lastBarTime;

//+------------------------------------------------------------------+
int OnInit() {
    initBalance = (InpReferenceBalance > 0) ? InpReferenceBalance : AccountBalance();
    lastBarTime = Time[0];
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
void OnTick() {
    // Only execute on new bar close
    if(Time[0] == lastBarTime) return;
    lastBarTime = Time[0];

    double currentEq = AccountEquity();
    double killswitchEq = initBalance * (1.0 - (InpHardStopEq / 100.0));
    double targetEq = initBalance * (1.0 + (InpProfitBuffer / 100.0));

    // Hard Stop Killswitch
    if(currentEq <= killswitchEq) {
        CloseAllPositions();
        Print("HARD STOP: Drawdown limit breached. Trading halted.");
        ExpertRemove();
        return;
    }

    // Only allow one open position
    if(OrdersTotal() > 0) return;

    // Structure detection: 5-bar lookback pivot
    int highestIdx = iHighest(NULL, 0, MODE_HIGH, 5, 2);
    int lowestIdx  = iLowest(NULL, 0, MODE_LOW, 5, 2);
    
    double lastPivotHigh = High[highestIdx];
    double lastPivotLow  = Low[lowestIdx];

    // Sweep conditions (Bar 1 swept the pivot and closed back inside)
    bool sweepShort = High[1] > lastPivotHigh && Close[1] < lastPivotHigh;
    bool sweepLong  = Low[1] < lastPivotLow && Close[1] > lastPivotLow;

    if(!sweepShort && !sweepLong) return;

    // Dynamic Size Calculation
    double activeRisk = (currentEq >= targetEq) ? InpScaledRiskPct : InpBaseRiskPct;
    double riskCapital = currentEq * (activeRisk / 100.0);
    
    double tickValue = MarketInfo(Symbol(), MODE_TICKVALUE);
    if(tickValue == 0) return; 

    // Lot calculation: Risk / (SL * TickValue)
    double rawLots = riskCapital / (InpSLPoints * tickValue);
    double step    = MarketInfo(Symbol(), MODE_LOTSTEP);
    double minLot  = MarketInfo(Symbol(), MODE_MINLOT);
    double maxLot  = MarketInfo(Symbol(), MODE_MAXLOT);
    
    double lotSize = MathFloor(rawLots / step) * step;
    if(lotSize < minLot) lotSize = minLot;
    if(lotSize > maxLot) lotSize = maxLot;

    // Execution
    if(sweepLong) {
        double sl = Ask - (InpSLPoints * Point);
        double tp = Ask + (InpTPPoints * Point);
        int ticket = OrderSend(Symbol(), OP_BUY, lotSize, Ask, 3, sl, tp, "HouseMoney L", InpMagicNumber, 0, clrBlue);
    }
    else if(sweepShort) {
        double sl = Bid + (InpSLPoints * Point);
        double tp = Bid - (InpTPPoints * Point);
        int ticket = OrderSend(Symbol(), OP_SELL, lotSize, Bid, 3, sl, tp, "HouseMoney S", InpMagicNumber, 0, clrRed);
    }
}

//+------------------------------------------------------------------+
void CloseAllPositions() {
    for(int i = OrdersTotal() - 1; i >= 0; i--) {
        if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
            if(OrderSymbol() == Symbol() && OrderMagicNumber() == InpMagicNumber) {
                if(OrderType() == OP_BUY)  OrderClose(OrderTicket(), OrderLots(), Bid, 3, clrWhite);
                if(OrderType() == OP_SELL) OrderClose(OrderTicket(), OrderLots(), Ask, 3, clrWhite);
            }
        }
    }
}