Track Emotional State and Rule Adherence Alongside P&L

[Fairman]

Add two additional columns to your existing trade journal, beyond the standard price and outcome data: "Followed plan? Yes/No" and "Emotional state at time of entry."

These two fields, tracked consistently and honestly over enough trades, tend to reveal one of the most important patterns available to any trader willing to look at their own data objectively. For a large number of traders, once they actually review this data, their biggest and most costly losses cluster heavily around entries marked "No" for plan adherence, combined with specific emotional states — frustration after a prior loss, impatience during a slow session, overconfidence after a winning streak.

This is a genuinely important discovery, because it locates the real problem far more precisely than a vague sense of "I need to trade better." It's not that the underlying strategy is broken. It's that a specific subset of trades — the ones taken outside the plan, during specific emotional states — are dragging down otherwise solid results.

Once you've identified this pattern in your own data, the fix becomes much more targeted and achievable: rather than trying to vaguely "improve overall," you can focus specifically on recognizing the emotional states that predict deviation, and building a habit of stepping away from the platform when you notice those specific states arising, before they translate into an off-plan trade.

[LondonScalper]

Tracking emotion + rule adherence next to P&L is how journals stop being highlight reels.

I score rule breaks even on green days. A green day with three violations is still a process loss — otherwise winning teaches the wrong lesson.

Do you use a 1–5 mood scale, or binary flags (tilt / FOMO / fatigue)?

[PropScalpDesk]

Add two additional columns to your existing trade journal: "Followed plan? Yes/No" and "Emotional state at time of entry."

Those two columns changed more on my desk than another indicator ever did. P&L alone congratulates luck and hides process. From Frankfurt I force Yes/No on plan adherence before I look at money — otherwise a green revenge ticket trains the wrong behaviour.

Prop angle: challenge reviews care about rule breaches as much as R. Emotional-state tags (“rushed”, “bored”, “repairing”) predict the soft daily stop better than chart screenshots.

Practical rule: if “Followed plan?” is No twice in a morning, I am done for the European block even if equity is green. The journal is a brake, not a scrapbook.

I also keep a weekly roll-up of those two columns. If “Followed plan? No” clusters on a specific session or pair, that pair loses size for a week. Emotional tags like “repairing” next to green tickets are a louder warning than red ones — they show what I am rewarding.

How honest is your emotional tag when the trade is still open — do you write it at entry, or only after you know the outcome?

[PTScalper]

Add two additional columns to your existing trade journal, beyond the standard price and outcome data: "Followed plan? Yes/No" and "Emotional state at time of entry."

These two fields, tracked consistently and honestly over enough trades, tend to reveal one of the most important patterns available to any trader willing to look at their own data objectively. For a large number of traders, once they actually review this data, their biggest and most costly losses cluster heavily around entries marked "No" for plan adherence, combined with specific emotional states — frustration after a prior loss, impatience during a slow session, overconfidence after a winning streak.

This is a genuinely important discovery, because it locates the real problem far more precisely than a vague sense of "I need to trade better." It's not that the underlying strategy is broken. It's that a specific subset of trades — the ones taken outside the plan, during specific emotional states — are dragging down otherwise solid results.

Once you've identified this pattern in your own data, the fix becomes much more targeted and achievable: rather than trying to vaguely "improve overall," you can focus specifically on recognizing the emotional states that predict deviation, and building a habit of stepping away from the platform when you notice those specific states arising, before they translate into an off-plan trade.

Hi Fairman,

Tracking the immediate emotional state at the time of entry is a crucial baseline, but the real existential threat to a trading account is the accumulation of stress over consecutive days.

When you are intensely focused on raw price action, waiting for the right structure to form on a daily or 15-minute chart, the mental fatigue compounds. It rarely takes just one bad mood to blow an account. It takes prolonged pressure—grinding through a choppy week, managing consecutive small drawdowns, or fighting the urge to overtrade—until your psychological capital is entirely depleted.

This cumulative exhaustion is exactly when catastrophic, account-breaking mistakes happen. After several days under pressure, the brain seeks relief or shortcuts. That is when a trader is most likely to:

Force a setup that doesn't meet the rules just to feel productive.

Move a stop-loss mid-trade because they cannot mentally handle another loss.

Revenge-trade with double the position size to wipe out a week's worth of frustration in one swing.

The underlying edge hasn't vanished; the operator has simply burned out.

To capture this reality, a trading journal needs to measure not just the emotion of the moment, but the broader stress context. Expanding those journal additions to include a "Mental Fatigue Score (1-10)" or tracking "Consecutive Days in Drawdown" can reveal the exact threshold where discipline historically breaks down. Once the data proves that sustained high stress correlates directly with off-plan execution, the mechanical fix becomes obvious: mandate a hard break from the screens to reset that mental capital before the pressure builds to the point of a blown account.

[PTScalper]

The most reliable mechanical triggers remove the decision-making process from your stressed brain entirely. When you are mentally fatigued, your willpower is the first thing to fail, so your triggers must rely on hard math, automated systems, and physical separation.

Here is how to construct rule-based triggers that actually protect your edge:

1. The Hard-Coded Circuit Breaker

Do not rely on a sticky note to tell you to stop trading. Write a script that forces you to. Utilize C# cAlgo, MQL, or Pine Script to build an automated order rejection tool that runs continuously in the background. Program it to automatically block new execution requests the moment your account hits a specific daily drawdown percentage or a set number of consecutive losses. If the script is actively rejecting your orders, the decision to step away is made for you.

2. The "Candle Penalty" for Rule Violations

Tie your timeouts directly to the timeframe you are trading. If you are watching price action on a 15-minute chart and you catch yourself forcing a trade or breaking a rule, impose a mandatory penalty of a specific number of candles (e.g., an 8-candle/2-hour lockout). Close the platform and do not reopen it until that time has elapsed. This allows the local market microstructure to completely reset and cycle past the setup that frustrated you.

[PTScalper]

3. The Drawdown Duration Threshold

Stress isn't just about the depth of a drawdown; it is about the duration. A slow, grinding three-day drawdown often causes more psychological damage than a single sharp loss. Set a rule based on time-in-drawdown: if your account remains in a net-negative state for three consecutive trading days, mandate a strict 24-hour complete blackout from the charts to reset your psychological capital.

4. Time-in-Chair Limits

Staring intensely at order flow and candlestick structure degrades your cognitive processing over time. Set a hard timer for 90 to 120 minutes of active chart time. When it goes off, you must physically leave the workstation. A true reset requires a physiological shift—taking the dog outside, going for a quick ride on the mountain bike, or just walking away from the screen entirely. Breaking the visual fixation on the monitors drops your heart rate and clears the accumulated tension.

5. The Profit-Preservation Trigger

Stress also spikes after a massive, rapid win, leading to overconfidence and immediate, sloppy give-backs. Institute a rule that if you hit a target representing a significant multiple of your average daily gain (e.g., hitting your weekly goal by Tuesday morning), you are mechanically triggered to close the platform for the rest of the session.

[PTScalper]

Because cTrader does not expose a pre-execution hook to disable the manual "Buy/Sell" UI buttons, a circuit breaker must be designed as an asynchronous "Guardian" bot. Instead of blocking the order submission, it continuously monitors account equity and aggressively intercepts the Positions.Opened and PendingOrders.Created events to instantly liquidate unauthorized trades.

Here is the architectural structure for a cAlgo cBot that enforces a hard daily loss limit across the entire account.

[PTScalper]

1. State Tracking and Initialization

The bot must establish a daily baseline to calculate accurate drawdowns. Relying purely on Account.Equity isn't enough; you need to calculate the exact starting balance at server midnight by subtracting today's closed PnL from the current balance.

2. Event-Driven Interception

By subscribing to position and order events in the OnStart() method, the bot doesn't just wait for the next tick to react. If a manual trade is placed out of frustration while the circuit breaker is active, the event handler fires immediately, closing the position within milliseconds.

3. The C# Guardian Implementation

This logic uses standard cAlgo API structures and LINQ to isolate today's performance and enforce the lockout.

[PTScalper]

Ctrader version 1.00

Code: Select all

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

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class GuardianCircuitBreaker : Robot
    {
        [Parameter("Max Daily Loss (Acct Currency)", DefaultValue = 500, MinValue = 1)]
        public double MaxDailyLoss { get; set; }

        private double _startOfDayBalance;
        private DateTime _currentDay;
        private bool _isLockedOut;

        protected override void OnStart()
        {
            UpdateStartOfDayBalance();
            
            // Bind event handlers to catch manual revenge trades instantly
            Positions.Opened += OnPositionOpened;
            PendingOrders.Created += OnPendingOrderCreated;
        }

        protected override void OnTick()
        {
            CheckNewDayReset();
            EvaluateDrawdown();
        }

        private void CheckNewDayReset()
        {
            if (Server.Time.Date != _currentDay)
            {
                UpdateStartOfDayBalance();
                _isLockedOut = false; 
                Print("New trading day. Circuit breaker reset.");
            }
        }

        private void UpdateStartOfDayBalance()
        {
            _currentDay = Server.Time.Date;
            
            // Calculate today's realized PnL using LINQ
            var todaysTrades = History.Where(x => x.ClosingTime.Date == _currentDay);
            var todaysRealizedPnL = todaysTrades.Sum(x => x.NetProfit);
            
            _startOfDayBalance = Account.Balance - todaysRealizedPnL;
        }

        private void EvaluateDrawdown()
        {
            if (_isLockedOut) return;

            // Calculate total daily drawdown (Realized + Unrealized)
            double currentLoss = _startOfDayBalance - Account.Equity;

            if (currentLoss >= MaxDailyLoss)
            {
                _isLockedOut = true;
                Print($"CIRCUIT BREAKER TRIGGERED: Daily loss limit of {MaxDailyLoss} reached.");
                LiquidateAccount();
            }
        }

        private void LiquidateAccount()
        {
            foreach (var position in Positions)
            {
                ClosePositionAsync(position);
            }

            foreach (var order in PendingOrders)
            {
                CancelPendingOrderAsync(order);
            }
        }

        private void OnPositionOpened(PositionOpenedEventArgs args)
        {
            if (_isLockedOut)
            {
                ClosePositionAsync(args.Position);
                Print("Trade intercepted and closed. Daily circuit breaker is active.");
            }
        }

        private void OnPendingOrderCreated(PendingOrderCreatedEventArgs args)
        {
            if (_isLockedOut)
            {
                CancelPendingOrderAsync(args.PendingOrder);
                Print("Pending order canceled. Daily circuit breaker is active.");
            }
        }
    }
}

[PTScalper]

Deploying this on a VPS or running it continuously on your workstation ensures the math overrides your psychology. Because it uses asynchronous execution methods (ClosePositionAsync), it avoids blocking the main thread during rapid liquidations, efficiently wiping the board clean before a tilt can cause deeper damage.