Pipsgrowth EX14003 Scalper

Pipsgrowth EX14003 is a time-window scalper. There are no indicators in the source — the signal is the clock. On every tick, the EA reads the current server time, converts it into hour/minute/second through MqlDateTime, and decides whether the present moment falls inside a 'strong signal' window or a 'weak signal' window. If the answer is strong, it opens a buy. If the answer is weak, it opens a sell. That is the entire signal stack.

The window length depends on the active timeframe. The OnTick handler runs a switch statement with six cases — PERIOD_M1, PERIOD_M5, PERIOD_M15, PERIOD_H1, PERIOD_H4, and PERIOD_D1 — plus a default branch for any unrecognised value. Each case has its own pair of timing inputs under the '=== Signal Timing ===' group. M1 fires when time_struct.sec < InpM1SignalSeconds (default 30 seconds). M5 fires when time_struct.min % InpM5Modulo == 0 AND time_struct.sec < InpM5SignalSeconds — i.e. on every fresh M5 bar, for the first 30 seconds. M15 fires when time_struct.min % InpM15Modulo == 0 and seconds are below 30. H1 — the default operating frame, set by the global g_InpTimeframe = PERIOD_H1 initialised at compile time — fires when time_struct.min < InpH1SignalMinutes, which is 5 minutes by default. H4 fires on every H4 bar with time_struct.hour % InpH4Modulo == 0 and minutes under 15. D1 fires when hour-of-day is under 2. The default branch uses current_time % InpDefaultModulo < InpDefaultSignalSeconds for any unsupported timeframe.

The mental model: the EA assumes the opening half-minute to quarter-hour of every fresh bar carries a directional impulse and trades long into it. Everything else — 99% of an M1 bar, 96% of an H1 bar, 92% of an H4 bar — is treated as a sell window. There is no price-action check, no volatility filter, no spread filter, no news guard, no session filter, no day-of-week filter. Time alone decides the side. The only external inputs that gate entries are the position-count check and the floating-loss kill.

Lot sizing is a balance treadmill. CalculateLot() returns StartLot + LotStep * (AccountBalance / BalanceStep), normalised to InpLotDecimals (2). With the defaults that resolves to 0.03 + 0.01 * (balance / 200). On the recommended $100 deposit you trade 0.03 lot. At $1,000 you trade 0.08 lot. At $5,000 you trade 0.28 lot. At $20,000 you trade 1.03 lot. The lot grows linearly with balance forever — there is no ceiling, no risk-percent cap, no equity-curve throttle, and no drawdown-based de-risking. Combined with the eight-trades-per-direction cap and the $100 absolute floating-loss kill (MaxLoss), the EA will grow into a serious position size if the account survives long enough for the math to compound.

Trade management is hard-coded into OpenTrade. TP is TakeProfitPoints * _Point (10 points default). For a five-digit forex pair that is 1 pip; for XAUUSD with 2 decimals (where _Point = 0.01) it is 10 cents; for 3-decimal gold (_Point = 0.001) it is 1 cent. The comment '10 pips' in the source is a label, not a guarantee — the actual pip value depends on broker digits. SL is price * InpStopLossPercent (0.5% of price), so on a $3,000 XAUUSD quote the stop is $15 away from entry. That is the asymmetry: SL is roughly a hundred times larger than TP on a typical gold tick. A single SL hit absorbs roughly a hundred TP wins, which means the strategy needs an extraordinarily high win rate to break even — and the source provides no signal logic that could deliver that.

Position caps are guarded by CountOpenPositions(direction). The implementation has a structural MQL5 mistake: it calls PositionSelect(InpSymbolName) inside a for (long i = 0; i < PositionsTotal(); i++) loop without using PositionGetTicket(i) to navigate the position list. In MQL5, PositionSelect is a symbol-based lookup, not an index-based one — so the loop is effectively a no-op that always re-selects the same position. The count is bound to whatever the symbol selector lands on, not the iteration. OpenTrade() then checks currentOpenTrades >= MaxTrades (default 8) before sending, so the safety is 'do not open more than 8 per direction' but the count itself is unreliable in the presence of multiple positions on the symbol. MaxHedges is defined in the inputs (default 1) but never read by any function in the file — it is a dead input that pretends to be a recovery cap.

Three retry helpers sit at the bottom of the file — TryClose_EX14003, TryClosePartial_EX14003, and TryModify_EX14003. They are correctly written: 3-attempt loops with 100 or 200 ms Sleep() calls on REQUOTE / TIMEOUT / PRICE_OFF / PRICE_CHANGED, returning true on the first TRADE_RETCODE_DONE. But the actual trade lifecycle uses raw OrderSend(request, result) in OpenTrade() — no retry, no partial-close path, no SL/TP modification path. The helpers are scaffolding for a future build that was never finished. The g_trade_wrappers_EX14003 CTrade instance they wrap is also unused in the live code.

Filling mode is auto-detected through GetFillingMode(), which checks SYMBOL_FILLING_MODE and returns FOK if the broker allows it, otherwise IOC, otherwise RETURN. For XAUUSD on most modern ECN/RAW brokers, FOK or IOC is available and the EA takes whichever the broker advertises. Deviation is fixed at 5 points; the source comment says 'smaller to avoid issues' but does not explain what issues.

Pacing. On every tick the EA prints the bid/ask to the journal — that is the loudest signal in the file that this is a diagnostic-grade build, not a production-tuned one. The MaxLoss check runs first on each tick: if AccountBalance - AccountEquity > MaxLoss (default $100), the EA stops placing new orders but does not close the ones already open. There is no trailing stop, no break-even move, no time-based exit, no equity-protection switch. A trade either hits TP, hits SL, or sits. The only way out of a drawdown is the broker hitting the static SL.

The default InpTimeframe input is invalid. The input declares values 1–7 (M1, M5, M15, M30, H1, H4, D1) but the default is 8. The internal g_InpTimeframe is a global initialised to PERIOD_H1 at compile time and never reassigned from InpTimeframe in OnInit. This means changing the InpTimeframe dropdown in MT5 has no effect — the EA always runs the H1 case. Treat the input as cosmetic until a future build wires InpTimeframe into g_InpTimeframe. The OnInit function is also absent from the file — there is no input validation, no handle setup, no pre-flight check.

What to expect in a backtest. The strategy has no directional bias. On H1 it will buy during the first 5 minutes of every hour and sell during the remaining 55. With TP at 10 points and SL at 0.5% of price, the math works out to roughly a 1:100 reward-to-risk ratio per trade. Even with a 90% win rate, the expected value per trade is negative once spread and commission are included, because the rare loss is roughly 100× the typical win. The strategy will print a long, flat, slightly positive curve on a commission-free historical feed with zero slippage, and a slow bleed on a realistic broker with commissions, slippage, and variable spread. Do not read the backtest equity line as evidence of edge — it is evidence of take-profit clustering plus the absence of slippage simulation in the MT5 strategy tester.

Who should run it. This is a curiosity piece, not a deployable strategy. The interesting parts are: the modular time-window switch with per-timeframe configurable windows, which is a clean template for bar-open momentum research; the balance-treadmill lot sizing, which is a clean example of a fixed-fraction-without-cap pattern; and the bug surface in CountOpenPositions, which is a real-world example of why PositionGetTicket matters in MQL5 position iteration. If you are studying how a 'bare minimum' tick-driven MT5 EA can be wired up with no indicators, this file is short enough to read in one sitting. If you are looking for a profitable gold scalper, look elsewhere in the catalogue.