Execution journal: measuring slippage by pair and session

[Fairman]

Chart expectancy lies when fills are ignored. I learned that on pairs that looked clean on M1/M5 but quietly taxed every entry through slippage and spread. My execution journal exists to measure requested price versus fill, by pair and by session — then to demote anything that charts well and bleeds on costs.

I still care about setup quality. I just refuse to grade a strategy on mid prices I never received. A “+1.2R” trade that filled 0.3R worse on entry and exited into widened spread is not the backtest screenshot.

What I log on every scalp (fast fields at the desk):

1. Pair and session tag — e.g. XAUUSD / London open, EURUSD / overlap.
2. Requested entry (limit/stop level) versus actual fill.
3. Spread at click, and again at exit if it mattered.
4. Slippage in the direction that hurts: positive when fill is worse than requested.
5. Planned R multiple versus realized R after costs.
6. One word on liquidity feel: normal, thin, or news-adjacent.

I do not write essays in the moment. Those fields are enough to aggregate later.

Weekly, or every 20–30 trades, I sort by pair and session: average slippage; average spread paid; expectancy after costs — not fantasy expectancy from candle wicks. Win rate is secondary; cost-adjusted expectancy is the gate.

Demotion rules I actually use:

- If a pair/session shows positive chart logic but near-zero or negative expectancy after costs over a meaningful sample, it drops from the A-list. No structure-was-perfect override.
- If slippage clusters around London open on one major while gold stays acceptable on my feed, I keep gold and demote that major for that window.
- If a pair only “works” when I ignore fill quality, it is not an edge. It is a screenshot hobby.

What this changed: I stopped forcing GBPUSD scalps in thin mid-morning pockets where fills were late. I kept XAUUSD in London when structure and fill stats both cleared. I cut size or stood aside when spread at click failed the max gate — logged as a non-trade.

Common trap: optimizing chart entries while execution quality decays. Another: averaging “small” slippage until a month of tuition shows as a flat curve despite a decent win rate.

I also tag news-adjacent and rollover minutes separately. Those rows often explain outliers. Mixed into “normal London,” they either over-punish a good pair or under-punish a bad window.

Process score still matters — rule adherence, setup grade, emotional tag. Execution metrics sit beside them. A high process score on a demoted pair/session does not restore it until cost-adjusted expectancy recovers in live data.

If your journal is only wins, losses, and feelings, add requested versus fill, spread, and session. Compute expectancy after costs. Demote what bleeds. Promote what still pays once the broker’s reality is included. Scalping edge is what survives contact with the order book — not what looks tradable on a paused chart.

[LondonScalper]

Execution journals > vibes. The moment you split slippage by pair and session, a few “good” chart pairs quietly fail the cost test.

I’d add p95 slip (not only average) and a simple demote rule: if all-in cost eats too much of the M-target for that session, it doesn’t earn screen space next week.

What’s your current worst offender — gold London open, or a quiet major that only looks cheap?

[LondonScalper]

Chart expectancy lies when fills are ignored. I learned that on pairs that looked clean on M1/M5 but quietly taxed every entry through slippage and spread.

Adding a bit more colour from the desk since the first reply: I now demote by session slice, not only by pair.

Example: EURUSD can look fine on paper in early London, then quietly worsen for my limit style once the NY open thickens and my fills start chasing. Gold is the reverse — sometimes the London open is the expensive window, and a later quieter patch is cheaper in slip even if the chart is uglier.

Fields that earned their keep beyond the basics: side (buy/sell), order type, and whether the slip happened on entry, exit, or both. Exit slip into a widening spread has killed more “+R” screenshots than bad entries for me.

Have you started weighting demotions by time-of-day buckets yet, or still at pair-level only?

[PropScalpDesk]

My execution journal exists to measure requested price versus fill, by pair and by session — then to demote anything that charts well and bleeds on costs.

Seconding the demote habit from a slightly different angle. I split the review into two questions: is the setup still valid on structure, and is the venue still payable at my hold times? A clean M15 reclaim can still be a bad business if p90 slippage on market exits eats the R.

Practical addition on this desk: I tag news-adjacent separately even when I did not trade the release. “Normal” averages hide the CPI tail. Prop blackout days stay in the log as flat-with-reason so I do not confuse discipline with missing edge.

Weekly sort is brutal and useful. EURUSD overlap might stay; a favourite cross at early London might get cut. Size only rises where the cost distribution is boring.

I keep the fields short on purpose. If journaling becomes an essay contest mid-session, I stop logging and start inventing.

Do you weight exit slippage as heavily as entry, or did entry surprises dominate your first sample?

[PTScalper]

Chart expectancy lies when fills are ignored. I learned that on pairs that looked clean on M1/M5 but quietly taxed every entry through slippage and spread. My execution journal exists to measure requested price versus fill, by pair and by session — then to demote anything that charts well and bleeds on costs.

I still care about setup quality. I just refuse to grade a strategy on mid prices I never received. A “+1.2R” trade that filled 0.3R worse on entry and exited into widened spread is not the backtest screenshot.

What I log on every scalp (fast fields at the desk):

1. Pair and session tag — e.g. XAUUSD / London open, EURUSD / overlap.
2. Requested entry (limit/stop level) versus actual fill.
3. Spread at click, and again at exit if it mattered.
4. Slippage in the direction that hurts: positive when fill is worse than requested.
5. Planned R multiple versus realized R after costs.
6. One word on liquidity feel: normal, thin, or news-adjacent.

I do not write essays in the moment. Those fields are enough to aggregate later.

Weekly, or every 20–30 trades, I sort by pair and session: average slippage; average spread paid; expectancy after costs — not fantasy expectancy from candle wicks. Win rate is secondary; cost-adjusted expectancy is the gate.

Demotion rules I actually use:

- If a pair/session shows positive chart logic but near-zero or negative expectancy after costs over a meaningful sample, it drops from the A-list. No structure-was-perfect override.
- If slippage clusters around London open on one major while gold stays acceptable on my feed, I keep gold and demote that major for that window.
- If a pair only “works” when I ignore fill quality, it is not an edge. It is a screenshot hobby.

What this changed: I stopped forcing GBPUSD scalps in thin mid-morning pockets where fills were late. I kept XAUUSD in London when structure and fill stats both cleared. I cut size or stood aside when spread at click failed the max gate — logged as a non-trade.

Common trap: optimizing chart entries while execution quality decays. Another: averaging “small” slippage until a month of tuition shows as a flat curve despite a decent win rate.

I also tag news-adjacent and rollover minutes separately. Those rows often explain outliers. Mixed into “normal London,” they either over-punish a good pair or under-punish a bad window.

Process score still matters — rule adherence, setup grade, emotional tag. Execution metrics sit beside them. A high process score on a demoted pair/session does not restore it until cost-adjusted expectancy recovers in live data.

If your journal is only wins, losses, and feelings, add requested versus fill, spread, and session. Compute expectancy after costs. Demote what bleeds. Promote what still pays once the broker’s reality is included. Scalping edge is what survives contact with the order book — not what looks tradable on a paused chart.

Hi Fairman,

This is a phenomenal post and exactly what separates an actual trading business from a “screenshot hobby.”

I stripped lagging technical indicators off my charts a long time ago to rely strictly on raw price action, mapping structure primarily on the daily and 15-minute timeframes. But even when a structural setup looks flawless on those higher timeframes, the reality of executing it—especially fast fields around the London open on pairs like XAUUSD—is entirely dictated by market microstructure, order book liquidity, and spread decay.

People optimize their chart entries to death, but a month of micro-slippage and spread easily bleeds out the edge. I’ve written automated order rejection and execution logging tools in C# for cAlgo and MQL precisely to track this delta between requested mid-price and actual fill. If a strategy's expectancy can't survive the broker's reality, it isn't an edge. Your demotion rules are ruthless in the best way possible.

To complement your manual journaling, I wrote a Pine Script utility for TradingView that visualizes this exact "Expectancy Bleed." It allows you to drop your planned Entry, Stop Loss, and Take Profit onto the chart, input your broker's average spread and slippage, and it instantly calculates your Cost-Adjusted R-Multiple versus your Theoretical R.

[PTScalper]

You can use it to visually backtest how much your setups are actually yielding once the fills are penalized.

Code: Select all

//@version=5
indicator("Cost-Adjusted Expectancy Logger", overlay=true)

// ----------------------------------------------------------------------
// 1. PLANNED TRADE INPUTS (Interactive on chart)
// ----------------------------------------------------------------------
grp1 = "Planned Trade (Use chart clicks to set)"
req_entry = input.price(defval=0.0, title="Requested Entry", confirm=true, group=grp1)
req_sl = input.price(defval=0.0, title="Requested Stop Loss", confirm=true, group=grp1)
req_tp = input.price(defval=0.0, title="Requested Take Profit", confirm=true, group=grp1)
is_long = input.bool(true, title="Is this a Long trade?", group=grp1)

// ----------------------------------------------------------------------
// 2. EXECUTION REALITY (Costs)
// ----------------------------------------------------------------------
grp2 = "Execution Costs (In Ticks/Pips)"
spread_ticks = input.float(1.5, title="Spread at Click", group=grp2)
slippage_entry = input.float(0.5, title="Slippage on Entry", group=grp2)
slippage_exit = input.float(1.0, title="Slippage on Exit (SL/TP)", group=grp2)

// Convert inputs to chart's mintick values
t_size = syminfo.mintick
spread_cost = spread_ticks * t_size
slip_in_cost = slippage_entry * t_size
slip_out_cost = slippage_exit * t_size

// ----------------------------------------------------------------------
// 3. CALCULATE REALIZED VS THEORETICAL
// ----------------------------------------------------------------------
// Actual Entry is penalized by spread and slippage
actual_entry = is_long ? req_entry + spread_cost + slip_in_cost : req_entry - spread_cost - slip_in_cost

// Actual SL is penalized by exit slippage
actual_sl = is_long ? req_sl - slip_out_cost : req_sl + slip_out_cost

// Actual TP is penalized by exit slippage (if hitting a limit, spread might matter, but keeping it simple)
actual_tp = is_long ? req_tp - slip_out_cost : req_tp + slip_out_cost

// R-Multiples
planned_risk = math.abs(req_entry - req_sl)
planned_reward = math.abs(req_tp - req_entry)
planned_r = planned_risk > 0 ? planned_reward / planned_risk : 0

actual_risk = math.abs(actual_entry - actual_sl)
actual_reward = math.abs(actual_tp - actual_entry)
actual_r = actual_risk > 0 ? actual_reward / actual_risk : 0

r_bleed = planned_r - actual_r

// ----------------------------------------------------------------------
// 4. DISPLAY DASHBOARD
// ----------------------------------------------------------------------
var table dash = table.new(position.bottom_right, 2, 5, bgcolor=color.new(color.black, 10), border_width=1, border_color=color.gray)

if barstate.islast
    // Headers
    table.cell(dash, 0, 0, "Metric", text_color=color.white, text_halign=text.align_left, bgcolor=color.new(color.blue, 70))
    table.cell(dash, 1, 0, "Value", text_color=color.white, text_halign=text.align_right, bgcolor=color.new(color.blue, 70))
    
    // Theoretical R
    table.cell(dash, 0, 1, "Theoretical R", text_color=color.gray, text_halign=text.align_left)
    table.cell(dash, 1, 1, str.tostring(planned_r, "#.##") + "R", text_color=color.gray, text_halign=text.align_right)
    
    // Cost-Adjusted R
    table.cell(dash, 0, 2, "Cost-Adjusted R", text_color=color.white, text_halign=text.align_left)
    table.cell(dash, 1, 2, str.tostring(actual_r, "#.##") + "R", text_color=actual_r > 0 ? color.green : color.red, text_halign=text.align_right)
    
    // R-Bleed (Expectancy Lost to Broker)
    table.cell(dash, 0, 3, "Expectancy Bleed", text_color=color.orange, text_halign=text.align_left)
    table.cell(dash, 1, 3, "-" + str.tostring(r_bleed, "#.##") + "R", text_color=color.orange, text_halign=text.align_right)

// ----------------------------------------------------------------------
// 5. VISUALIZE REAL LEVELS ON CHART
// ----------------------------------------------------------------------
if barstate.islast
    line.new(bar_index - 10, req_entry, bar_index + 5, req_entry, color=color.new(color.blue, 50), style=line.style_dashed, width=1)
    line.new(bar_index - 10, actual_entry, bar_index + 5, actual_entry, color=color.blue, style=line.style_solid, width=2)
    
    label.new(bar_index + 5, req_entry, "Req Entry", color=color.new(color.blue, 100), textcolor=color.new(color.blue, 50), style=label.style_label_left)
    label.new(bar_index + 5, actual_entry, "Real Entry", color=color.new(color.blue, 100), textcolor=color.blue, style=label.style_label_left)

[PTScalper]

How to use it:

When you apply it to your chart, it will prompt you to click three times to set your Entry, Stop Loss, and Take profit. It will immediately plot dashed lines for your "fantasy" screenshot entries, and solid lines for your actual fills based on the spread and slippage inputs. The table in the bottom right will show you exactly how much expectancy you are bleeding to the order book.

[PTScalper]

If you are already building automated order-rejection and logging logic in C# for cAlgo or MQL, you know that this data isn't just for reviewing past trades; it is for mapping toxic liquidity windows. If a pair requires you to ignore execution quality to show a positive R-multiple, it’s a synthetic edge that only exists on a paused feed. Your demotion rules treat execution decay as a primary technical filter, which is exactly how institutional desks operate.

To push the TradingView side of this quantitative approach to the next level, I’ve engineered a more advanced Pine Script. Instead of just visualizing a single static trade, this Execution Drag & Dynamic Risk Modeler calculates your Minimum Viable Win Rate (MVWR) to survive the broker's specific tax. Crucially, it calculates position sizing based on the worst-case modeled fill, ensuring your pre-defined risk percentage doesn't invisibly inflate due to entry and exit slippage.

[PTScalper]

PineScript:

Code: Select all

//@version=5
indicator("Pro Execution Drag & Risk Modeler", overlay=true)

// ----------------------------------------------------------------------
// 1. STRATEGY & RISK PARAMETERS
// ----------------------------------------------------------------------
grp_risk = "Capital & Risk Profiling"
acct_balance = input.float(100000, title="Account Balance ($)", group=grp_risk)
risk_percent = input.float(1.0, title="Risk Per Trade (%)", step=0.1, group=grp_risk)

grp_trade = "Trade Coordinates (Interactive)"
req_entry = input.price(defval=0.0, title="Requested Entry", confirm=true, group=grp_trade)
req_sl = input.price(defval=0.0, title="Requested Stop Loss", confirm=true, group=grp_trade)
req_tp = input.price(defval=0.0, title="Requested Take Profit", confirm=true, group=grp_trade)
is_long = input.bool(true, title="Direction: Long?", group=grp_trade)

// ----------------------------------------------------------------------
// 2. MICROSTRUCTURE / EXECUTION COSTS
// ----------------------------------------------------------------------
grp_exec = "Execution Cost Modeling (Ticks/Pips)"
spread_ticks = input.float(1.5, title="Average Spread at Click", group=grp_exec)
slippage_in = input.float(0.5, title="Negative Slippage (Entry)", group=grp_exec)
slippage_out = input.float(1.0, title="Negative Slippage (Exit/Stop)", group=grp_exec)

// Value conversions
t_size = syminfo.mintick
t_val = syminfo.pointvalue

spread_cost = spread_ticks * t_size
slip_in_cost = slippage_in * t_size
slip_out_cost = slippage_out * t_size

// ----------------------------------------------------------------------
// 3. THEORETICAL VS REALIZED CALCULATIONS
// ----------------------------------------------------------------------
// Theoretical (The Screenshot Trade)
theo_risk_dist = math.abs(req_entry - req_sl)
theo_reward_dist = math.abs(req_tp - req_entry)
theo_r = theo_risk_dist > 0 ? theo_reward_dist / theo_risk_dist : 0

// Realized (The Broker's Reality)
real_entry = is_long ? req_entry + spread_cost + slip_in_cost : req_entry - spread_cost - slip_in_cost
real_sl = is_long ? req_sl - slip_out_cost : req_sl + slip_out_cost
real_tp = is_long ? req_tp - slip_out_cost : req_tp + slip_out_cost

real_risk_dist = math.abs(real_entry - real_sl)
real_reward_dist = math.abs(real_tp - real_entry)
real_r = real_risk_dist > 0 ? real_reward_dist / real_risk_dist : 0

// Risk Inflation Factor (How much your risk expands if you size based on theory but fill in reality)
risk_inflation = real_risk_dist > 0 and theo_risk_dist > 0 ? (real_risk_dist / theo_risk_dist) - 1 : 0

// Dynamic Position Sizing (Sized to the REALIZED risk, not theoretical)
risk_amount = acct_balance * (risk_percent / 100)
// Prevent divide by zero in size calculation
unit_size = real_risk_dist > 0 ? risk_amount / (real_risk_dist * t_val / t_size) : 0

// Expectancy Metrics
r_bleed_pct = theo_r > 0 ? ((theo_r - real_r) / theo_r) * 100 : 0
// Minimum Viable Win Rate (Break Even Win Rate after costs)
mvwr = real_r > 0 ? (1 / (1 + real_r)) * 100 : 100

// ----------------------------------------------------------------------
// 4. INSTITUTIONAL HUD (Heads Up Display)
// ----------------------------------------------------------------------
var table hud = table.new(position.bottom_right, 2, 7, bgcolor=color.rgb(12, 14, 21, 10), border_width=1, border_color=color.rgb(42, 46, 57))

if barstate.islast
    table.cell(hud, 0, 0, "EXECUTION TELEMETRY", text_color=color.white, text_halign=text.align_left, bgcolor=color.rgb(29, 78, 216, 40))
    table.cell(hud, 1, 0, syminfo.ticker, text_color=color.white, text_halign=text.align_right, bgcolor=color.rgb(29, 78, 216, 40))
    
    table.cell(hud, 0, 1, "Theoretical R", text_color=color.gray, text_halign=text.align_left)
    table.cell(hud, 1, 1, str.tostring(theo_r, "#.##") + "R", text_color=color.gray, text_halign=text.align_right)
    
    table.cell(hud, 0, 2, "Realized Net R", text_color=color.white, text_halign=text.align_left)
    table.cell(hud, 1, 2, str.tostring(real_r, "#.##") + "R", text_color=real_r > 1 ? color.teal : color.red, text_halign=text.align_right)
    
    table.cell(hud, 0, 3, "Expectancy Bleed", text_color=color.orange, text_halign=text.align_left)
    table.cell(hud, 1, 3, str.tostring(r_bleed_pct, "#.#") + "%", text_color=color.orange, text_halign=text.align_right)

    table.cell(hud, 0, 4, "Risk Inflation Tax", text_color=color.red, text_halign=text.align_left)
    table.cell(hud, 1, 4, "+" + str.tostring(risk_inflation * 100, "#.#") + "%", text_color=color.red, text_halign=text.align_right)

    table.cell(hud, 0, 5, "Adjusted Position Size", text_color=color.yellow, text_halign=text.align_left)
    table.cell(hud, 1, 5, str.tostring(unit_size, "#.##") + " Units", text_color=color.yellow, text_halign=text.align_right)

    table.cell(hud, 0, 6, "Min. Required Win Rate", text_color=color.silver, text_halign=text.align_left)
    table.cell(hud, 1, 6, str.tostring(mvwr, "#.#") + "%", text_color=color.silver, text_halign=text.align_right)

// ----------------------------------------------------------------------
// 5. CHART PROJECTIONS
// ----------------------------------------------------------------------
if barstate.islast
    // The "Screenshot" Trade Lines (Dashed, faded)
    line.new(bar_index - 15, req_entry, bar_index + 10, req_entry, color=color.new(color.gray, 60), style=line.style_dashed, width=1)
    line.new(bar_index - 15, req_sl, bar_index + 10, req_sl, color=color.new(color.maroon, 60), style=line.style_dashed, width=1)
    
    // The Execution Reality Lines (Solid, distinct)
    line.new(bar_index - 15, real_entry, bar_index + 10, real_entry, color=color.blue, style=line.style_solid, width=2)
    line.new(bar_index - 15, real_sl, bar_index + 10, real_sl, color=color.red, style=line.style_solid, width=2)
    line.new(bar_index - 15, real_tp, bar_index + 10, real_tp, color=color.teal, style=line.style_solid, width=2)
    
    label.new(bar_index + 10, real_entry, "Net Entry", color=color.new(color.blue, 100), textcolor=color.blue, style=label.style_label_left, size=size.small)
    label.new(bar_index + 10, real_sl, "Net Stop", color=color.new(color.red, 100), textcolor=color.red, style=label.style_label_left, size=size.small)

[PTScalper]

Key upgrades in this telemetry model:

Risk Inflation Tax: If you normally calculate your position size using the visual chart structure, this metric shows you exactly how much your 1% risk inflates due to spread and slippage.

Dynamic Position Sizing: The script outputs the exact unit size required to keep your risk at exactly your chosen parameter after the liquidity tax is taken out of your fill.

Minimum Required Win Rate: It translates the decayed R-multiple into a harsh baseline—showing you the exact win rate required simply to break even on that specific pair, at that specific time of day, against that specific order book depth.