When a cheaper commission broker still cost me more

[LondonScalper]

When cheaper commission still cost me more

I moved once for a lower commission headline. Month-end log: I had “saved” on commission and lost more on wider median spreads, a few ugly slips around the open, and two reject streaks that pushed me into chase fills. Effective cost was worse. Lesson learned — slowly, and with a bruised ego about “smart” broker shopping.

What I check now instead of the brochure:

• All-in cost per lot on my hours, not their average banner
• Reject behaviour when I am impatient (that is when it hurts)
• Whether rebate maths assumes volume I do not actually trade
• Support path when something breaks mid-session

Cheapest is not best; predictable is best for scalping. Happy to hear similar war stories — especially where a “premium” book earned its keep, or where a mid-tier surprised you on the upside. Numbers from your own hours beat any comparison video filmed on a quiet Wednesday demo.

[PTScalper]

When cheaper commission still cost me more

I moved once for a lower commission headline. Month-end log: I had “saved” on commission and lost more on wider median spreads, a few ugly slips around the open, and two reject streaks that pushed me into chase fills. Effective cost was worse. Lesson learned — slowly, and with a bruised ego about “smart” broker shopping.

What I check now instead of the brochure:

• All-in cost per lot on my hours, not their average banner
• Reject behaviour when I am impatient (that is when it hurts)
• Whether rebate maths assumes volume I do not actually trade
• Support path when something breaks mid-session

Cheapest is not best; predictable is best for scalping. Happy to hear similar war stories — especially where a “premium” book earned its keep, or where a mid-tier surprised you on the upside. Numbers from your own hours beat any comparison video filmed on a quiet Wednesday demo.

Hi LondonScalper,

Spot on. I think every scalper has to pay that "cheap commission" tuition fee at least once. It usually happens right around the time you start scaling up your lot sizes and those brochure numbers suddenly meet the reality of a live order book.

I learned this the hard way trading 15-minute price action setups. I moved to a budget broker because the $1.50 per side commission looked fantastic on paper. But exactly as you said, the median spread during my active hours was quietly bleeding me dry. What completely broke the camel’s back was the slippage during minor liquidity sweeps. A 0.5 pip slip on a tight stop-loss instantly destroys the risk-to-reward ratio of a scalp, making the commission savings mathematically irrelevant. Predictable fills at a slightly higher premium will always outperform a cheap book that ghosts you when volatility spikes.

Since you mentioned checking the "all-in cost per lot on my hours," here is a utility script in Pine that visualizes exactly that.

[PTScalper]

One quick heads-up: TradingView only provides ask and bid data in real-time, not historically. This script won't paint on past candles, but if you leave it running on a live chart during your session, it calculates your true overhead (Live Spread + Round-Turn Commission converted to ticks) and flags exactly when your total execution cost crosses your acceptable threshold.

Code: Select all

//@version=5
indicator("Live All-In Cost Tracker", overlay=false)

// -------------------------------------------------------------------------
// INPUTS
// -------------------------------------------------------------------------
comm_rt = input.float(6.0, title="Round-Turn Commission per Lot ($)")
tick_val = input.float(10.0, title="Value of 1 Tick/Pip per Lot ($)")
max_cost = input.float(1.5, title="Max Acceptable Overhead (Ticks/Pips)", step=0.1)

// -------------------------------------------------------------------------
// CALCULATIONS
// -------------------------------------------------------------------------
// Calculate live spread in native ticks/pips
// (ask and bid only update on live incoming ticks, historical bars will read na)
spread_ticks = (ask - bid) / syminfo.mintick

// Convert fixed commission into a tick/pip equivalent
comm_ticks = comm_rt / tick_val

// True all-in cost per trade
total_cost = spread_ticks + comm_ticks

// -------------------------------------------------------------------------
// PLOTTING
// -------------------------------------------------------------------------
// Dynamic color: Red if it exceeds our acceptable threshold, Teal if it's safe
cost_color = total_cost > max_cost ? color.new(color.red, 40) : color.new(color.teal, 40)

plot(total_cost, title="Total Execution Cost", style=plot.style_columns, color=cost_color)
hline(max_cost, title="Pain Threshold", color=color.gray, linestyle=hline.style_dashed)

// Add a label for quick reading of the live value
if barstate.isrealtime
    lbl_text = "All-In Cost: " + str.tostring(total_cost, "#.##") + " ticks"
    label.new(bar_index, total_cost, text=lbl_text, style=label.style_label_left, 
              color=color.new(color.black, 100), textcolor=cost_color, size=size.normal)

[PTScalper]

You can tweak the commission and tick value inputs to match whatever asset you are currently trading. It’s highly revealing to watch this histogram spike right at the open or during a news event—it shows you exactly how much extra risk you are taking on just to get the fill. Anyone else here have a specific mid-tier broker that actually holds their spread together during the open?

[PTScalper]

To quantify this, here is a diagnostic script in Pine to track real-time execution drag.

Because TradingView only streams ask and bid data in real-time (no historical tick data is retained for past bars), this script acts as a live session monitor. It converts your fixed round-turn commission into a tick/pip equivalent and adds it to the live spread, plotting your absolute overhead per trade.

[PTScalper]

More pro Pine Script:

Code: Select all

//@version=5
indicator("Live Execution Drag Monitor", overlay=false)

// -------------------------------------------------------------------------
// PARAMETERS
// -------------------------------------------------------------------------
comm_rt   = input.float(6.0, title="Round-Turn Commission per Lot ($)")
tick_val  = input.float(10.0, title="Value of 1 Tick/Pip per Lot ($)")
max_drag  = input.float(1.5, title="Maximum Allowable Drag (Ticks/Pips)", step=0.1)

// -------------------------------------------------------------------------
// MICROSTRUCTURE CALCULATIONS
// -------------------------------------------------------------------------
// Calculate live spread in native ticks/pips (Updates on real-time ticks only)
spread_ticks = (ask - bid) / syminfo.mintick

// Convert fixed commission into a tick/pip equivalent
comm_ticks = comm_rt / tick_val

// Total execution cost (Effective Spread + Commission)
effective_cost = spread_ticks + comm_ticks

// -------------------------------------------------------------------------
// VISUALIZATION
// -------------------------------------------------------------------------
// Flag overhead spikes that exceed the defined structural tolerance
cost_color = effective_cost > max_drag ? color.new(color.maroon, 30) : color.new(color.teal, 30)

plot(effective_cost, title="Effective Execution Cost", style=plot.style_columns, color=cost_color)
hline(max_drag, title="Tolerance Threshold", color=color.gray, linestyle=hline.style_dashed)

// Display realtime metrics on the most recent bar
if barstate.isrealtime
    lbl_text = "Effective Drag: " + str.tostring(effective_cost, "#.##") + " ticks"
    label.new(bar_index, effective_cost, text=lbl_text, style=label.style_label_left, 
              color=color.new(color.black, 100), textcolor=cost_color, size=size.normal)

[PTScalper]

Running this on a secondary monitor during the open or a macroeconomic release provides immediate quantitative feedback on how much risk you are absorbing just to get the fill.

Has anyone here audited their execution quality after migrating from a standard retail environment to a Direct Market Access (DMA) or FIX API setup? I would be interested to see hard data on fill latency and slippage improvements during high-volume node transitions.

[PTScalper]

Porting this logic to MetaTrader offers a massive structural advantage over Pine Script: native access to the asset's exact tick value (SYMBOL_TRADE_TICK_VALUE) and historical spread retention (spread[]).

While TradingView requires you to manually input the tick value and cannot paint historical spread data, MQL reads the broker's environment directly. These scripts dynamically convert your fixed account commission into the exact tick equivalent for any asset—whether you drop it on a Gold chart, an FX pair, or an equity index—and paint the historical execution drag across past bars so you can backtest your broker's behavior during liquidity sweeps.

[PTScalper]

MT5 / MQL5 Implementation

MQL5 handles dynamic coloring cleanly via DRAW_COLOR_HISTOGRAM. The script uses real-time Ask/Bid pricing for the live bar and relies on the broker's historical spread[] array to paint past execution drag.

Code: Select all

//+------------------------------------------------------------------+
//|                                     LiveExecutionDragMonitor.mq5 |
//+------------------------------------------------------------------+
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_plots   1
#property indicator_type1   DRAW_COLOR_HISTOGRAM
#property indicator_color1  clrTeal, clrMaroon
#property indicator_width1  2

input double InpCommissionRoundTurn = 6.0;  // Round-Turn Commission (Account Currency)
input double InpMaxAllowableDrag    = 15.0; // Max Drag (in Ticks/Points)

double CostBuffer[];
double ColorBuffer[];

int OnInit()
  {
   SetIndexBuffer(0, CostBuffer, INDICATOR_DATA);
   SetIndexBuffer(1, ColorBuffer, INDICATOR_COLOR_INDEX);
   
   IndicatorSetString(INDICATOR_SHORTNAME, "Effective Drag Monitor");
   IndicatorSetDouble(INDICATOR_LEVELVALUE, 0, InpMaxAllowableDrag);
   IndicatorSetInteger(INDICATOR_LEVELCOLOR, 0, clrGray);
   IndicatorSetInteger(INDICATOR_LEVELSTYLE, 0, STYLE_DASH);
   
   PlotIndexSetInteger(0, PLOT_COLOR_INDEXES, 2);
   PlotIndexSetInteger(0, PLOT_LINE_COLOR, 0, clrTeal);
   PlotIndexSetInteger(0, PLOT_LINE_COLOR, 1, clrMaroon);
   
   return(INIT_SUCCEEDED);
  }

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   double tick_size = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   double tick_value = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double point_size = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   
   if(tick_size == 0 || tick_value == 0) return 0;
   
   // Convert fiat commission to tick equivalent dynamically based on asset
   double comm_ticks = InpCommissionRoundTurn / tick_value;
   
   int start = (prev_calculated > 0) ? prev_calculated - 1 : 0;
   
   for(int i = start; i < rates_total; i++)
     {
      double current_spread_ticks = 0;
      
      if(i == rates_total - 1)
        {
         // Live microsecond tick precision for the current active bar
         double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
         double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
         current_spread_ticks = (ask - bid) / tick_size;
        }
      else
        {
         // Historical approximation using broker's stored spread array
         current_spread_ticks = (spread[i] * point_size) / tick_size;
        }
      
      double effective_cost = current_spread_ticks + comm_ticks;
      CostBuffer[i] = effective_cost;
      
      // 0 = Teal (Safe), 1 = Maroon (Drag exceeds tolerance)
      ColorBuffer[i] = (effective_cost > InpMaxAllowableDrag) ? 1 : 0;
     }
   
   // Chart UI Overlay
   double live_cost = CostBuffer[rates_total - 1];
   string status = (live_cost > InpMaxAllowableDrag) ? "[!] DRAG EXCEEDS TOLERANCE" : "[+] EXECUTABLE CONDITIONS";
   Comment(status,
           "\nEffective Drag: ", DoubleToString(live_cost, 1), " ticks",
           "\nLive Spread: ", DoubleToString(live_cost - comm_ticks, 1), " ticks",
           "\nCommission Eq: ", DoubleToString(comm_ticks, 1), " ticks");
           
   return(rates_total);
  }

[PTScalper]

MT4 / MQL4 Implementation

Because MQL4 does not support a native DRAW_COLOR_HISTOGRAM as cleanly as MT5, we utilize two separate buffers (one for acceptable drag, one for excessive drag) to achieve the exact same visual flagging.

Code: Select all

//+------------------------------------------------------------------+
//|                                     LiveExecutionDragMonitor.mq4 |
//+------------------------------------------------------------------+
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 clrTeal
#property indicator_color2 clrMaroon
#property indicator_width1 2
#property indicator_width2 2

input double InpCommissionRoundTurn = 6.0;  // Round-Turn Commission (Account Currency)
input double InpMaxAllowableDrag    = 15.0; // Max Drag (in Ticks/Points)

double SafeBuffer[];
double DangerBuffer[];

int OnInit()
  {
   SetIndexBuffer(0, SafeBuffer);
   SetIndexStyle(0, DRAW_HISTOGRAM);
   SetIndexLabel(0, "Safe Drag");
   
   SetIndexBuffer(1, DangerBuffer);
   SetIndexStyle(1, DRAW_HISTOGRAM);
   SetIndexLabel(1, "High Drag");
   
   IndicatorShortName("Effective Drag Monitor");
   IndicatorSetDouble(INDICATOR_LEVELVALUE, 0, InpMaxAllowableDrag);
   IndicatorSetInteger(INDICATOR_LEVELCOLOR, 0, clrGray);
   IndicatorSetInteger(INDICATOR_LEVELSTYLE, 0, STYLE_DASH);
   
   return(INIT_SUCCEEDED);
  }

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   ArraySetAsSeries(spread, true);
   
   double tick_size = MarketInfo(Symbol(), MODE_TICKSIZE);
   double tick_value = MarketInfo(Symbol(), MODE_TICKVALUE);
   double point_size = Point;
   
   if(tick_size == 0 || tick_value == 0 || point_size == 0) return 0;
   
   double comm_ticks = InpCommissionRoundTurn / tick_value;
   
   int limit = rates_total - prev_calculated;
   if(limit > 1) limit = rates_total - 1;
   
   for(int i = limit; i >= 0; i--)
     {
      double current_spread_ticks = 0;
      
      if(i == 0)
        {
         double ask = MarketInfo(Symbol(), MODE_ASK);
         double bid = MarketInfo(Symbol(), MODE_BID);
         current_spread_ticks = (ask - bid) / tick_size;
        }
      else
        {
         current_spread_ticks = (spread[i] * point_size) / tick_size;
        }
      
      double effective_cost = current_spread_ticks + comm_ticks;
      
      if(effective_cost <= InpMaxAllowableDrag)
        {
         SafeBuffer[i] = effective_cost;
         DangerBuffer[i] = 0.0;
        }
      else
        {
         DangerBuffer[i] = effective_cost;
         SafeBuffer[i] = 0.0;
        }
     }
     
   double live_cost = SafeBuffer[0] + DangerBuffer[0];
   string status = (SafeBuffer[0] == 0) ? "[!] DRAG EXCEEDS TOLERANCE" : "[+] EXECUTABLE CONDITIONS";
   Comment(status,
           "\nEffective Drag: ", DoubleToString(live_cost, 1), " ticks",
           "\nLive Spread: ", DoubleToString(live_cost - comm_ticks, 1), " ticks",
           "\nCommission Eq: ", DoubleToString(comm_ticks, 1), " ticks");
           
   return(rates_total);
  }