Killzone timing: do you trade fixed clock or volume bursts?

[LondonScalper]

Killzone timing: fixed clock versus waiting for volume bursts.

I have tried both. Fixed clock (e.g. first 90 minutes of London) keeps me honest and stops all-day drifting. Waiting for a volume/pace burst feels smarter until I invent bursts that are not there.

Hybrid I use now
Clock defines the window where I am allowed to look. Inside the window, I still need pace and spread to look tradable -- a dead open stays flat even if the clock says "killzone." Outside the window, I need an exceptional, pre-written reason, not a vibe.

Pure clock people: how do you handle lifeless opens? Pure burst people: how do you avoid staring until you force a trade?

I am interested in rules that survive a quiet Tuesday, not just a trending Monday.

Volume burst definitions should be written: e.g. pace clearly above the prior thirty-minute average and spreads still inside the filter. Vague "it feels alive" returns you to clock-only trading with extra steps. If you cannot define the burst, you cannot audit it on Sunday.

[PTScalper]

Killzone timing: fixed clock versus waiting for volume bursts.

I have tried both. Fixed clock (e.g. first 90 minutes of London) keeps me honest and stops all-day drifting. Waiting for a volume/pace burst feels smarter until I invent bursts that are not there.

Hybrid I use now
Clock defines the window where I am allowed to look. Inside the window, I still need pace and spread to look tradable -- a dead open stays flat even if the clock says "killzone." Outside the window, I need an exceptional, pre-written reason, not a vibe.

Pure clock people: how do you handle lifeless opens? Pure burst people: how do you avoid staring until you force a trade?

I am interested in rules that survive a quiet Tuesday, not just a trending Monday.

Volume burst definitions should be written: e.g. pace clearly above the prior thirty-minute average and spreads still inside the filter. Vague "it feels alive" returns you to clock-only trading with extra steps. If you cannot define the burst, you cannot audit it on Sunday.

Hi LondonScalper,

Relying on a strict hybrid approach is the most effective way to protect both capital and mental bandwidth, as it directly addresses the fatal flaws of the two extremes. The core issue with pure clock trading is capital bleed by a thousand tiny cuts during consolidation, while pure burst trading drains mental capital through screen fatigue until you inevitably hallucinate a setup.

Pure clock traders survive lifeless opens through hard-coded volatility gates. If the clock says the killzone is open, but the price action leading into it is entirely contained within a narrow, illiquid band, the structure dictates sitting on your hands. To survive a quiet Tuesday, a clock-driven trader implements a strict cancellation rule: if the first three 5-minute candles of the open fail to break the pre-market range or lack a specific point expansion, the killzone is declared dead and the session is skipped. They accept that time is a necessary condition, but never a sufficient one.

Pure burst traders avoid the "stare and force" trap by delegating the waiting to a machine. You cannot trust human eyes to objectively measure a volume burst after two hours of watching a dead chart; the brain wants to trade and will invent a reason to click. Because raw price action, spread dynamics, and volume are quantifiable, the solution is scripting an alert that completely divorces you from the screen. A disciplined burst trader stays away from the monitors until an automated script fires, dictating that the current 1-minute volume has exceeded a 30-period rolling average by at least 2.5x. If the alert stays silent, they do not look at the market.

[PTScalper]

Your hybrid model is the sweet spot, but building rules that survive a quiet Tuesday requires mechanics that are flawlessly auditable during a Sunday review.

The Volume-to-Spread Ratio
A volume burst is only tradable if the liquidity supports it. If a burst triggers but the spread widens beyond your strict maximum threshold, it is a news vacuum or toxic flow, not a tradable entry. Your rule must state clearly: "1-minute volume > 150% of the 30-minute average AND spread < X." If both conditions aren't met, the burst is invalid.

The Structural Accomplishment
A volume spike in the middle of a tight consolidation is just noise. To be valid, the burst must achieve something structurally on the chart, such as a clean liquidity sweep of a prior 15-minute swing high or low. The objective audit question becomes: "Did this burst actually trap traders and clear a level, or was it just high-volume chop?"

The Time Decay Protocol
If the required volume and pace conditions are not met within the first half of your fixed clock window, the probability of a clean, sustained trend drops drastically. A surviving rule for a quiet Tuesday dictates that if the setup takes too long to form, profit targets must be aggressively halved, or the remainder of the session is simply abandoned.

[PTScalper]

To completely step away from the monitors, your script needs to evaluate three booleans simultaneously: the time window, the relative volume multiplier, and the real-time spread threshold.

Because you cannot reliably query real-time spread history in TradingView (Pine Script relies on chart data, not tick-level order books), the most robust way to build this is at the execution level using C# for cTrader (cAlgo) or MQL5, where spread is a native, real-time property.

Here is how to script the complete logic.

[PTScalper]

1. The Execution-Grade Approach (C# cAlgo)

This cAlgo indicator runs strictly on live ticks. It calculates the 30-period Simple Moving Average of tick volume on the closed bars, compares it to the live forming bar, and gates the alert with a strict spread filter.

Code: Select all

using System;
using cAlgo.API;
using cAlgo.API.Indicators;

namespace cAlgo
{
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class KillzoneRvolSpreadAlert : Indicator
    {
        [Parameter("Volume Lookback", DefaultValue = 30)]
        public int Lookback { get; set; }

        [Parameter("Burst Multiplier", DefaultValue = 2.0)]
        public double Multiplier { get; set; }

        [Parameter("Max Spread (Pips)", DefaultValue = 0.8)]
        public double MaxSpread { get; set; }

        [Parameter("Session Start (UTC)", DefaultValue = "07:00")]
        public string SessionStart { get; set; }

        [Parameter("Session End (UTC)", DefaultValue = "10:00")]
        public string SessionEnd { get; set; }

        private SimpleMovingAverage _volSma;
        private bool _alertFiredForCurrentBar;

        protected override void Initialize()
        {
            // Calculate baseline volume using tick volume
            _volSma = Indicators.SimpleMovingAverage(Bars.TickVolumes, Lookback);
        }

        public override void Calculate(int index)
        {
            // Only evaluate in real-time to capture live spread dynamics
            if (!IsLastBar) return;

            var timeOfDay = Server.Time.TimeOfDay;
            var start = TimeSpan.Parse(SessionStart);
            var end = TimeSpan.Parse(SessionEnd);
            
            bool inKillzone = timeOfDay >= start && timeOfDay <= end;

            if (!inKillzone) 
            {
                _alertFiredForCurrentBar = false; 
                return;
            }

            // Reset the alert state at the start of a new 1m/5m candle
            if (Bars.TickVolumes[index] <= 1) _alertFiredForCurrentBar = false;

            // Baseline is the SMA of the previous closed bars
            double avgVol = _volSma.Result[index - 1];
            double currentVol = Bars.TickVolumes[index];
            double currentSpread = Symbol.Spread / Symbol.PipSize;

            bool isBurst = currentVol > (avgVol * Multiplier);
            bool isSpreadValid = currentSpread <= MaxSpread;

            if (isBurst && isSpreadValid && !_alertFiredForCurrentBar)
            {
                Notifications.PlaySound(SoundType.Ring);
                Chart.DrawText("Burst_" + index, "🔥 BURST", index, Bars.LowPrices[index], Color.Red);
                
                // Lock the alert so it doesn't spam every tick for the rest of the candle
                _alertFiredForCurrentBar = true; 
            }
        }
    }
}

[PTScalper]

2. The Charting Approach (TradingView Pine Script)

If you prefer to keep visual alerts in TradingView and handle execution separately, you can script the time and RVOL gates in Pine Script. Since TV doesn't natively expose live spread to the alert engine reliably, this acts as your "heads up" to check the desk.

Code: Select all

//@version=5
indicator("Killzone RVOL Alert", overlay=true)

// Inputs
lookback = input.int(30, "RVOL Lookback")
multiplier = input.float(2.0, "Burst Multiplier")
killzone = input.session("0700-1000", "Killzone (Exchange Time)")

// 1. Time Gate
inKillzone = not na(time(timeframe.period, killzone))

// 2. RVOL Gate
avgVol = ta.sma(volume, lookback)
isBurst = (volume > (avgVol * multiplier)) and inKillzone

// Visuals
plotshape(isBurst, style=shape.triangleup, color=color.new(color.blue, 0), location=location.belowbar, size=size.small)

// Alert Condition
if isBurst
    alert("Volume Burst in Killzone. Check spreads.", alert.freq_once_per_bar)

[PTScalper]

The Operational Workflow

To avoid the "stare and force" trap, turn your monitor off or switch to a completely different workspace. When the cAlgo sound plays (or the TradingView webhook fires), you look at the chart. You have exactly 30 seconds to answer the structural question: "Did this burst sweep a liquidity level, or is it just chop?" If it's chop, you turn the monitor back off.

[PTScalper]

Because TradingView cannot natively write to local files or query live tick spreads, this logic must live inside your execution environment. In cAlgo (C#), you can intercept the exact tick where the relative volume is met but the spread exceeds your threshold, and write that event directly to a CSV or a database.

Here is the C# implementation using a local CSV file. This is the most lightweight approach for weekend auditing, as you can instantly drop the output into Excel or a Python script to analyze the time-of-day distribution of toxic flow.

The cAlgo C# Logger
You must elevate the indicator's access rights to AccessRights.FileSystem to allow System.IO operations.

Code: Select all

using System;
using System.IO;
using cAlgo.API;
using cAlgo.API.Indicators;

namespace cAlgo
{
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.FileSystem)]
    public class ToxicFlowLogger : Indicator
    {
        [Parameter("Volume Lookback", DefaultValue = 30)]
        public int Lookback { get; set; }

        [Parameter("Burst Multiplier", DefaultValue = 2.0)]
        public double Multiplier { get; set; }

        [Parameter("Max Spread (Pips)", DefaultValue = 0.8)]
        public double MaxSpread { get; set; }

        [Parameter("Log File Path", DefaultValue = @"C:\TradingLogs\ToxicFlow.csv")]
        public string LogFilePath { get; set; }

        private SimpleMovingAverage _volSma;
        private bool _loggedForCurrentBar;

        protected override void Initialize()
        {
            _volSma = Indicators.SimpleMovingAverage(Bars.TickVolumes, Lookback);
            
            // Ensure directory exists
            var dir = Path.GetDirectoryName(LogFilePath);
            if (!Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }
        }

        public override void Calculate(int index)
        {
            if (!IsLastBar) return;

            // Reset state at the open of a new candle
            if (Bars.TickVolumes[index] <= 1) _loggedForCurrentBar = false;

            double avgVol = _volSma.Result[index - 1];
            double currentVol = Bars.TickVolumes[index];
            double currentSpread = Symbol.Spread / Symbol.PipSize;

            bool isBurst = currentVol > (avgVol * Multiplier);
            bool isSpreadValid = currentSpread <= MaxSpread;

            // Trigger ONLY when volume is present but liquidity is pulled (toxic flow)
            if (isBurst && !isSpreadValid && !_loggedForCurrentBar)
            {
                LogEvent(currentVol, avgVol, currentSpread);
                _loggedForCurrentBar = true; // Lock out the rest of the candle
            }
        }

        private void LogEvent(double vol, double avgVol, double spread)
        {
            try
            {
                bool writeHeader = !File.Exists(LogFilePath);
                
                // Using StreamWriter to append to the CSV
                using (StreamWriter sw = new StreamWriter(LogFilePath, true))
                {
                    if (writeHeader)
                    {
                        sw.WriteLine("Timestamp_UTC,Symbol,RVOL_Ratio,Tick_Volume,Avg_Volume,Actual_Spread,Max_Allowed_Spread");
                    }
                    
                    double rvolRatio = Math.Round(vol / avgVol, 2);
                    string logLine = $"{Server.Time:yyyy-MM-dd HH:mm:ss},{Symbol.Name},{rvolRatio},{vol},{Math.Round(avgVol, 1)},{spread},{MaxSpread}";
                    
                    sw.WriteLine(logLine);
                }
            }
            catch (Exception ex)
            {
                Print($"Failed to write to toxic flow log: {ex.Message}");
            }
        }
    }
}

[PTScalper]

Enterprise Database Integration

If you prefer to aggregate this data alongside broader market metrics rather than managing flat files, you can bypass the CSV entirely. Because cAlgo is a standard .NET environment, you can integrate external libraries to pipe this data directly into your backend infrastructure.

REST API via HttpClient: Change AccessRights to AccessRights.Internet. Swap the StreamWriter logic for System.Net.Http.HttpClient. You can serialize the payload to JSON and fire a fire-and-forget POST request to an ASP.NET Core microservice that handles the database insertion asynchronously.

Direct MS SQL Server Connection: Change AccessRights to AccessRights.FullAccess. Reference System.Data.SqlClient (or Microsoft.Data.SqlClient if using modern .NET wrappers within cAlgo) and execute a direct INSERT stored procedure into an MS SQL Server instance on your workstation.

By logging the RVOL_Ratio alongside the Actual_Spread, your Sunday audit will immediately reveal if the highest volume bursts routinely correlate with the most aggressive liquidity withdrawals—a definitive signature of institutional stop runs rather than genuine continuation breakouts.