Daily Loss Limits Save Careers

[Fairman]

Set a hard daily loss cap before you ever open your platform — somewhere around 3-5% of account equity is common — and when you hit it, you are done trading for the day. No exceptions, no "just one more to make it back," no negotiating with yourself in the moment.

Why is this rule non-negotiable for scalpers specifically? Because scalping generates dozens of decision points every single session.

Each individual loss chips away slightly at your judgment, and the temptation to "win it back" compounds with every additional loss. By the third or fourth losing trade in a row, most traders aren't executing their strategy anymore — they're executing their frustration.

A daily loss limit removes the decision entirely, which is exactly the point. You don't have to trust your emotionally compromised self at 2pm after three consecutive stop-outs to make a good call. You just have to trust the rule you wrote down that morning, when you were calm and thinking clearly.

Write the number down. Set an alert if your platform supports it. And treat hitting that limit not as a failure, but as the plan working exactly as designed — because the alternative, an account with no daily stop, is how a bad morning turns into a blown week.

[LondonScalper]

Set a hard daily loss cap before you ever open your platform — somewhere around 3-5% of account equity is common — and when you hit it, you are done trading for the day.

Daily loss limits really do save careers — or at least save the months that would have been spent rebuilding after one stupid afternoon.

I’d only tighten the framing: for a scalper, 3–5% daily is already a wide gate unless the account is tiny or the mandate is aggressive. Many prop books effectively force something tighter via daily DD rules. On a personal discretionary book I live closer to a small fixed cash amount that would annoy me, not a percentage that still lets me dig a crater.

Mechanics that make the cap real:

• Pre-commit in writing before the open
• Platform / equity stop where possible — willpower is a weak API
• No “flat and restart” loopholes the same day

The cap’s job is to stop the second story (“I can make it back before NY”). That story is expensive.

Where do you set yours in practice — percent, or a fixed R multiple of average daily risk?

[PropScalpDesk]

Daily loss limits are career equipment

A daily loss limit is not motivational wallpaper. It is how full-time traders still have a desk next month — including the mornings when the open looks perfect and your head is not.

My version has two layers:

• Soft stop — two full R losers or a written minus-R threshold on the day → done, walk, journal three lines.
• Hard stop — absolute cash amount → flatten everything, platform closed, no chart “research” that is really another trade.

On prop accounts the firm’s daily loss is the hard wall; my soft stop sits inside it on purpose. Hitting the firm line to “learn your limit” is an expensive teacher. The rule only works if it is pre-committed. Negotiating after the second loss is how limits die.

Where do you set soft versus hard — and have you ever kept trading past soft because the setup was “too good”? What happened to the rest of that day?

[FTtrader]

Set a hard daily loss cap before you ever open your platform — somewhere around 3-5% of account equity is common — and when you hit it, you are done trading for the day. No exceptions, no "just one more to make it back," no negotiating with yourself in the moment.

Why is this rule non-negotiable for scalpers specifically? Because scalping generates dozens of decision points every single session.

Each individual loss chips away slightly at your judgment, and the temptation to "win it back" compounds with every additional loss. By the third or fourth losing trade in a row, most traders aren't executing their strategy anymore — they're executing their frustration.

A daily loss limit removes the decision entirely, which is exactly the point. You don't have to trust your emotionally compromised self at 2pm after three consecutive stop-outs to make a good call. You just have to trust the rule you wrote down that morning, when you were calm and thinking clearly.

Write the number down. Set an alert if your platform supports it. And treat hitting that limit not as a failure, but as the plan working exactly as designed — because the alternative, an account with no daily stop, is how a bad morning turns into a blown week.

Hi Fairman,

I completely agree. Setting a hard, non-negotiable daily loss limit is the ultimate safety net for any trader, but for scalpers, it is an absolute requirement for long-term survival.

Furthermore, you are entirely right to frame this strictly in percentages of account equity rather than a fixed dollar amount.

Here is why anchoring that daily stop to a percentage (like the 3–5% range you mentioned) is the only mathematically and psychologically sound way to manage risk:

Percentages scale dynamically: A fixed dollar amount is arbitrary. If you set a hard cap at "$500," that number means something entirely different to a $10,000 account than it does to a $50,000 account. By locking your daily max loss to a percentage, your risk automatically scales as your account grows or shrinks, ensuring you never disproportionately leverage your current equity.

Dollars trigger emotional attachment: We attach real-world value to dollar amounts (e.g., "$500 is a car payment"). Thinking in dollars accelerates the exact emotional breakdown and "revenge trading" you described. Thinking in percentages keeps the math abstract and objective, making it easier to accept the loss as just a cost of doing business.

It protects the compounding curve: If you cap your worst days at a strict 3% to 5% equity drawdown, mathematical recovery is always within reach. A single bad day only sets you back a day or two of good trading. Without that percentage cap, a spiraling trader can easily wipe out 20% of their equity in an afternoon, requiring a massive, statistically improbable win streak just to get back to breakeven.

[FTtrader]

Scalping is high-velocity warfare against your own discipline. Because the market offers a new setup every few seconds, the barrier to entry for a "revenge trade" is dangerously low. As you perfectly summarized, by the third consecutive stop-out, you are no longer trading your edge—you are trading your ego.

By setting a strict percentage-based kill switch before the market even opens, you defer the decision to the calm, logical version of yourself. Hitting that 4% drawdown isn't a failure; it is flawless execution of your risk management plan. It is exactly what ensures you live to trade tomorrow.

[FTtrader]

This cTrader cBot automatically enforces your percentage-based daily loss limit. It constantly monitors both your realized PnL (closed trades for the day) and unrealized PnL (currently open positions). If your total daily drawdown hits your hard cap, it instantly liquidates all open positions and shuts itself down to prevent any further trading.

[FTtrader]

How to use this script:

1.) Open cTrader and go to the Automate tab.

2.) Click New cBot and name it something like DailyLossManager.

3.) Replace all the default code with the script below.

4.) Click Build (the hammer icon).

5.) Add an instance of this bot to any chart and set your Max Daily Loss (%) in the parameters before clicking start.

Code: Select all

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class DailyLossManager : Robot
    {
        [Parameter("Max Daily Loss (%)", DefaultValue = 3.0, MinValue = 0.1, Step = 0.1)]
        public double MaxDailyLossPercentage { get; set; }

        private double _startOfDayBalance;
        private DateTime _currentDay;

        protected override void OnStart()
        {
            // Record the initial balance and date when the bot starts
            _currentDay = Server.Time.Date;
            _startOfDayBalance = Account.Balance;
            
            Print("Daily Loss Manager active. Hard cap set at {0}% of starting balance ({1}).", 
                  MaxDailyLossPercentage, _startOfDayBalance);
        }

        protected override void OnTick()
        {
            // Reset the tracking variables at the start of a new server day
            if (Server.Time.Date != _currentDay)
            {
                _currentDay = Server.Time.Date;
                _startOfDayBalance = Account.Balance;
                Print("New trading day. Balance reset to {0}", _startOfDayBalance);
            }

            EnforceLossCap();
        }

        private void EnforceLossCap()
        {
            // 1. Calculate PnL of all trades closed today
            var dailyClosedPnL = History
                .Where(t => t.ClosingTime.Date == _currentDay)
                .Sum(t => t.NetProfit);

            // 2. Calculate PnL of all currently open positions
            var openPnL = Positions.Sum(p => p.NetProfit);

            // 3. Combine for total daily floating/realized PnL
            var totalDailyPnL = dailyClosedPnL + openPnL;

            // 4. Check if the account is in a net loss for the day
            if (totalDailyPnL < 0)
            {
                // Calculate current loss as a percentage of the start-of-day balance
                double lossPercentage = (Math.Abs(totalDailyPnL) / _startOfDayBalance) * 100;

                if (lossPercentage >= MaxDailyLossPercentage)
                {
                    Print("HARD CAP REACHED: {0}%. Liquidating positions and terminating bot.", 
                          Math.Round(lossPercentage, 2));
                    
                    CloseAllPositions();
                    
                    // Stop() disables the cBot so it cannot open new trades
                    Stop(); 
                }
            }
        }

        private void CloseAllPositions()
        {
            // Asynchronously close all open positions across all symbols
            foreach (var position in Positions)
            {
                ClosePositionAsync(position);
            }
        }
    }
}

[FTtrader]

A quick note on deployment: You only need to run this bot on one chart. Because Positions and History query the entire account, this script will monitor and close trades across all currency pairs and assets you are trading that day, removing the decision-making process from your hands completely.

[FTtrader]

To make this a professional-grade risk management tool, we need to upgrade it from a simple script to a robust utility.

Here are the "Pro" upgrades included in this version:

Mid-Day Recovery Calculation: If cTrader crashes or you restart the bot mid-day, the basic version would incorrectly reset your start-of-day balance to your current balance. The pro version retroactively calculates your true 00:00 start balance by looking into your daily trade history.

On-Chart HUD: It paints a live, low-latency dashboard on your chart showing your starting balance, floating PnL, and current drawdown percentage so you never have to guess how close you are to the limit.

CPU Optimization: It shifts from OnTick (which fires every single price change and drains CPU) to OnTimer(1) (which runs exactly once per second) to keep your platform running smoothly.

Pending Order Cancellation: When you tilt, triggering the kill switch isn't enough if you have pending limit/stop orders waiting to execute. The pro version cancels all pending orders alongside liquidating open positions.

Alerts & Categorization: Parameters are grouped into UI-friendly categories, and it includes the ability to send an email and play a sound when the limit is breached.

[FTtrader]

The Pro cTrader Script: ProDailyRiskManager

Code: Select all

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class ProDailyRiskManager : Robot
    {
        // --- PARAMETERS ---
        [Parameter("Max Daily Loss (%)", DefaultValue = 3.0, MinValue = 0.1, Step = 0.1, Group = "Risk Limits")]
        public double MaxDailyLossPercentage { get; set; }

        [Parameter("Cancel Pending Orders", DefaultValue = true, Group = "Kill Switch Actions")]
        public bool CancelPending { get; set; }

        [Parameter("Send Email Alert", DefaultValue = false, Group = "Notifications")]
        public bool SendEmailAlert { get; set; }

        [Parameter("Email Address", DefaultValue = "[email protected]", Group = "Notifications")]
        public string EmailAddress { get; set; }

        [Parameter("Show On-Chart HUD", DefaultValue = true, Group = "User Interface")]
        public bool ShowHud { get; set; }

        // --- INTERNAL VARIABLES ---
        private double _startOfDayBalance;
        private DateTime _currentDay;
        private bool _limitHit = false;

        protected override void OnStart()
        {
            InitializeDay();
            
            // Pro Optimization: Use a 1-second timer instead of OnTick to save CPU
            Timer.Start(1); 
        }

        private void InitializeDay()
        {
            _currentDay = Server.Time.Date;
            
            // Pro touch: Calculate true start of day balance in case the bot was restarted mid-day
            var todayClosedPnL = History
                .Where(t => t.ClosingTime.Date == _currentDay)
                .Sum(t => t.NetProfit);
            
            _startOfDayBalance = Account.Balance - todayClosedPnL;
            _limitHit = false;

            Print("Risk Manager initialized. True Start of Day Balance: {0}", _startOfDayBalance);
        }

        protected override void OnTimer()
        {
            if (_limitHit) return;

            // Check if we rolled over into a new trading day
            if (Server.Time.Date != _currentDay)
            {
                InitializeDay();
            }

            // Calculate metrics
            var dailyClosedPnL = History.Where(t => t.ClosingTime.Date == _currentDay).Sum(t => t.NetProfit);
            var openPnL = Positions.Sum(p => p.NetProfit);
            var totalDailyPnL = dailyClosedPnL + openPnL;
            
            // Current PnL as a percentage of the start balance
            double currentPnLPercentage = (totalDailyPnL / _startOfDayBalance) * 100;

            UpdateHUD(totalDailyPnL, currentPnLPercentage);

            // Check for breach (converting max loss to a negative number for comparison)
            if (currentPnLPercentage <= -MaxDailyLossPercentage)
            {
                ExecuteKillSwitch(currentPnLPercentage);
            }
        }

        private void ExecuteKillSwitch(double hitPercentage)
        {
            _limitHit = true;
            Print("KILL SWITCH TRIGGERED: {0}% Drawdown", Math.Round(hitPercentage, 2));

            // 1. Cancel all pending limit and stop orders
            if (CancelPending)
            {
                foreach (var order in PendingOrders)
                {
                    CancelPendingOrderAsync(order);
                }
            }

            // 2. Liquidate all open positions
            foreach (var position in Positions)
            {
                ClosePositionAsync(position);
            }

            // 3. Fire Notifications
            if (SendEmailAlert)
            {
                Notifications.SendEmail("[email protected]", EmailAddress, "Daily Loss Cap Reached", 
                    $"Your account hit the daily loss limit of {MaxDailyLossPercentage}%. All positions closed and pending orders canceled.");
            }
            Notifications.PlaySound(SoundType.DoorBell);

            // 4. Update UI with warning
            Chart.DrawStaticText("killMsg", "\n\nDAILY LOSS CAP REACHED.\nTRADING LOCKED FOR THE DAY.", 
                VerticalAlignment.Center, HorizontalAlignment.Center, Color.Red);
            
            // 5. Terminate bot
            Stop();
        }

        private void UpdateHUD(double totalDailyPnL, double percentage)
        {
            if (!ShowHud) return;

            string status = _limitHit ? "LOCKED" : "ACTIVE";
            Color textColor = percentage < 0 ? Color.Tomato : Color.MediumSeaGreen;

            string text = $"--- RISK DASHBOARD ---\n" +
                          $"Start Balance: {_startOfDayBalance:F2}\n" +
                          $"Daily Net PnL: {totalDailyPnL:F2}\n" +
                          $"Drawdown: {percentage:F2}% / -{MaxDailyLossPercentage}%\n" +
                          $"Status: {status}";

            // Draw to the top left of the chart
            Chart.DrawStaticText("riskHud", text, VerticalAlignment.Top, HorizontalAlignment.Left, textColor);
        }
    }
}