I will code your EAs and Indicators for no charge

Thanks for taking the time to look into it and for sharing your version I appreciate the effort.
From what I can see, your implementation focuses mainly on ATR displacement as a noise filter, which makes sense and explains why the trades are fewer and cleaner. That aligns well with my intention to eliminate low-quality, low-displacement moves.
That said, I’ve since stripped the EA down further, aiming for something simpler but more robust, where directional bias, structure context, and timing come first, and volatility acts more as a permission layer rather than the core decision engine. So while the surface behavior may look similar, the underlying logic and trade intent are different.
I’ll definitely test your version it’s useful for comparison. And if BestTraderEv is willing to look into my current code or logic, I’d be very grateful, as a second set of experienced eyes is always valuable.
Thanks again for contributing

"This still needs further tweaking and fine adjustments. Every setting is extremely sensitive. The ATR isn't simple/easy to handle at all."

Because you guys mention my nick, I will say this:
Any attempt to detect meaningful volatility is in vain.
Sure, we can detect volatility spikes, but what does this fact mean?
In reality, it can mean either a continuation or an upthrust/shakeout.
So, how do we figure out which one it is before we know which one it was???

Also, Bollinger Bands is already such an indicator...

You’re absolutely right volatility by itself is non-directional. A spike can resolve as continuation just as easily as a shakeout, and without context you only know what it was after the fact.Appreciate you weighing in

Hi sagat1977 / BestTradeEv,
I’m currently experimenting with an AO-based momentum filter and wanted to get your thoughts on whether this logic keeps me consistently on the right side of the market, and how it could be improved to avoid entries near exhaustion.
Below is the core idea (simplified):

1. I read AO on the last closed bar, the bar before it, and the live bar
2. Define phase:
   1. AO rising → green phase (momentum increasing)
   2. AO falling → red phase (momentum decreasing)

3. Measure directional momentum strength as the absolute AO change between bars
4. Classify momentum into STRONG / GOOD / WEAK zones
5. Allow buys only when:
   1. AO > 0
   2. AO is green
   3. Momentum strength exceeds a threshold

6. Allow sells only when:
   1. AO < 0
   2. AO is red
   3. Momentum strength exceeds a threshold

7. Use the live AO bar only as an early warning for potential phase reversal, not as a trigger

Conceptually, this works well for trading momentum expansion, but I’m concerned about two edge cases:

1. Buying near peaks
   AO can still be green and above zero even when price is already extended and mean reversion risk is high.
2. Selling near troughs
   Same issue in reverse when AO is red but downside momentum is already exhausted.

My questions to you:

1. Do you think this AO phase + strength model is structurally sound for staying on the right side of the market?
2. From your experience, what is the best way to detect mean reversion or exhaustion using AO (or AO + price) so trades are not triggered near peaks/troughs?
3. Would you recommend:
   1. Normalizing AO strength vs ATR?
   2. Adding a “momentum deceleration” filter (e.g. green bars but shrinking)?
   3. Combining AO with a structural price reference (range high/low, VWAP, fractal, etc.)?

4. If you were to modify this snippet, what one condition would you add to block late entries without killing valid momentum trades?

I’m deliberately trying to keep this mechanical and non-subjective, so any insight on how you’d harden this logic would be appreciated.
Thanks in advance — I’d really value your perspective on this.
// ── AO VALUES (closed + live)
double aoNow = iAO(Symbol(), 0, 1); // last CLOSED bar
double aoPrev = iAO(Symbol(), 0, 2); // previous closed bar
double aoLive = iAO(Symbol(), 0, 0); // current LIVE bar

// ── AO PHASE DETECTION
bool greenPhase = (aoNow > aoPrev); // momentum increasing
bool redPhase = (aoNow < aoPrev); // momentum decreasing

// ── EARLY WARNING (LIVE BAR REVERSAL CHECK)
bool aboutToSwitchToRed = false;
bool aboutToSwitchToGreen = false;

double potentialChange;

if(greenPhase)
{
potentialChange = aoNow - aoLive;
if(aoLive < aoNow && potentialChange >= WarningThreshold)
aboutToSwitchToRed = true;
}

if(redPhase)
{
potentialChange = aoLive - aoNow;
if(aoLive > aoNow && potentialChange >= WarningThreshold)
aboutToSwitchToGreen = true;
}

// ── MOMENTUM STRENGTH (DIRECTIONAL)
double momentumChange = aoNow - aoPrev;
double momentumStrength = 0;

if(greenPhase)
momentumStrength = momentumChange; // positive strength
else if(redPhase)
momentumStrength = MathAbs(momentumChange); // normalize negative

// ── MOMENTUM QUALITY ZONES
bool allowTrade = false;
string momentumQuality;

if(momentumStrength >= StrongMomentumMin)
{
momentumQuality = "STRONG";
allowTrade = true;
}
else if(momentumStrength >= GoodMomentumMin)
{
momentumQuality = "GOOD";
allowTrade = true;
}
else if(momentumStrength >= WeakMomentumMin)
{
momentumQuality = "WEAK";
allowTrade = AllowWeakMomentum;
}
else
{
momentumQuality = "VERY WEAK";
allowTrade = false;
}

// ── FORCE STRONG-ONLY MODE (OPTIONAL)
if(AllowOnlyStrong && momentumStrength < StrongMomentumMin)
allowTrade = false;

// ── FINAL AO PERMISSION LOGIC
bool allowBuy = (greenPhase && allowTrade);
bool allowSell = (redPhase && allowTrade);


Best regards,
Ififils

I use the indicators for pullback trading. I wait until the candle pulls back to the line and then I enter. I use the RSI versions for smaller, faster scalping. I love the RSI version. You can achieve very good win rate results.

Facebook Does anyone know what this girl’s exact strategy is? I’m interested!

I am guessing that a google of "IBLV Trading" probably tells you everything you need to know.

"The strategy is not publicly available in detail - it's a pay-to-learn model. The public marketing materials mainly cover the 'what' and 'where' questions, but the 'how exactly' part is only available in the Discord community and courses. But I think the girl is a scammer. If her bot is always profitable, she wouldn't share it. She would be making billions."
If someone truly has a consistently profitable automated trading strategy, the logical questions are:
Why sell it for $65/month instead of scaling the capital?
Why risk diluting edge by teaching thousands of people the same setups?
If the bot makes "$1000/day reliably," why not just compound that into millions/billions?

I agree - but unfortunately as long as we have a world full of people that want to be multi-millionaires without actually having to work for it, scammers will continue to sell crap to people that believe the hype. You could argue the 'scammers' are not the idiots, they are actually making money out of true idiots and lazy people.

Can we add this ea recovery option for loss trades with its recovery martingale factor till to recover full.

Yes! This needs fine-tuning and improvements. The basics are more or less there. Worth developing and refining the EA further. The field is open / free to go.

Hello everyone, traders in this community, is there an indicator or tool that draws what I've attached in the image on the boom or crash chart? What I'm looking for are the parallel lines on the Spikes as shown in the graph.

Sagat1977, if possible, please provide screenshots of the trade opening locations for both indicators separately. I'd be very grateful. # post 80,847

Dear Fellow traders,please giev me suggestions what to do my exness broker has closed my trades of 200dollars and i see the reasons are partial close and many trades are closed by hedged profitable trades to losing trades.They are blaming that my EA has done that.I dont have any EA that does that.

False chart patterns (or fake breakouts) aren’t always losing trades. Very often the price candles move away from the line/level for a moment, but then quickly reverse back. By the time that happens, the trailing stop has usually already moved very tight — frequently reaching breakeven or even a small profit. (rsi version)
nrtr atr

rsi nrtr atr

Thank you very much. I'll try to figure this out.

Fake breakouts are one of the biggest challenges in price action trading. Using ATR/NRTR to adjust stop placement dynamically really helps it gives the market some breathing room while protecting capital. For me the pattern that stands out is when the breakout lacks volume follow-through; that’s usually a sign it’ll reverse.

I've tried many different strategies already. None of them worked; this is the only ATR pullback strategy that's profitable for me. The market constantly pulls back. The ATR lines roughly accurately indicate the support and resistance levels. I'm thinking about how to further develop the indicator. How to filter out more false signals.

Hello everyone!
can someone help me fix this EA for mt5?
i created it from AI and nomatter how it fixes it still comes up with errors here is the code.
//+------------------------------------------------------------------+
//| FollowTheCandle.mq5 |
//| 2026 Follow The Candle Project |
//+------------------------------------------------------------------+
#property copyright " 2026 Follow The Candle Project"
#property version "1.26"
#property strict
//--- input parameters
input string TradeStartTime = "08:00"; // Time to identify reference candle
input ENUM_TIMEFRAMES Timeframe = PERIOD_M15; // Candle timeframe
input bool UsePercentRisk = false; // true = risk %, false = fixed lots
input double LotSize = 0.10; // Fixed lot size
input double RiskPercent = 1.0; // % of balance to risk
input int StopLossPips = 20; // SL offset in pips from reference candle
input double TakeProfitMultiplier = 2.0; // TP = SL * multiplier
input int MagicNumber = 20260117; // Unique EA ID
input bool UseEquityForRisk = true; // use equity instead of balance for risk calc
input bool UseMarketEntry = true; // true = market order, false = pending (not implemented)
//--- internal variables
datetime refCandleTime = 0;
double refHigh=0.0, refLow=0.0, refOpen=0.0, refClose=0.0;
bool referenceSet = false;
bool tradeOpened = false;
int lastTradeDay = -1;
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
MqlDateTime current;
TimeToStruct(TimeCurrent(), current);
lastTradeDay = current.day;
referenceSet = false;
tradeOpened = false;
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
// nothing special for now
}
//+------------------------------------------------------------------+
//| Utility: returns pip size (1 pip in price units) |
//+------------------------------------------------------------------+
double GetPipSize(string symbol)
{
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
if(digits == 3 || digits == 5)
return(point * 10.0);
return(point);
}
//+------------------------------------------------------------------+
//| Utility: normalize lot to symbol step and bounds |
//+------------------------------------------------------------------+
double NormalizeLotToStep(string symbol, double lot)
{
double volMin = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
double volMax = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
double volStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
if(volStep <= 0.0) volStep = 0.01;
double steps = MathRound(lot / volStep);
double normalized = steps * volStep;
normalized = MathMax(normalized, volMin);
normalized = MathMin(normalized, volMax);
int precision = 0;
double tmp = volStep;
while(tmp < 1.0 - 1e-12) { tmp *= 10.0; precision++; if(precision>8) break; }
return NormalizeDouble(normalized, precision);
}
//+------------------------------------------------------------------+
//| Risk-based lot calculation |
//+------------------------------------------------------------------+
double CalculateLotByRisk(double sl, double entry)
{
double balance = AccountInfoDouble(ACCOUNT_BALANCE);
double equity = AccountInfoDouble(ACCOUNT_EQUITY);
double riskBase = UseEquityForRisk ? equity : balance;
double riskValue = riskBase * RiskPercent / 100.0;
double pip = GetPipSize(_Symbol);
double slDistancePips = MathAbs(entry - sl) / pip;
if(slDistancePips <= 0.0) return LotSize;
double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
double pipValuePerLot = 0.0;
if(tickSize > 0.0)
pipValuePerLot = tickValue * (pip / tickSize);
if(pipValuePerLot <= 0.0)
pipValuePerLot = 1.0;
double slMoneyPerLot = slDistancePips * pipValuePerLot;
if(slMoneyPerLot <= 0.0) return LotSize;
double lots = riskValue / slMoneyPerLot;
if(lots < SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN))
lots = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
return NormalizeLotToStep(_Symbol, lots);
}
//+------------------------------------------------------------------+
//| Robust parsing of TradeStartTime (accepts H:MM or HH:MM) |
//+------------------------------------------------------------------+
void ParseStartTime(string sTime, int &hour, int &min)
{
hour = 0;
min = 0;
string trimmed = StringTrim(sTime);
if(StringLen(trimmed) == 0) return;
string dt = "1970.01.01 " + trimmed;
datetime t = StringToTime(dt);
if(t == 0) return;
MqlDateTime tm;
TimeToStruct(t, tm);
hour = tm.hour;
min = tm.min;
if(hour < 0 || hour > 23) hour = 0;
if(min < 0 || min > 59) min = 0;
}
//+------------------------------------------------------------------+
//| Place market order and confirm position |
//+------------------------------------------------------------------+
bool OpenTradeAtPrice(ENUM_ORDER_TYPE type, double triggerOpen, datetime triggerTime)
{
double pip = GetPipSize(_Symbol);
double sl, tp, lot;
// Use current market price for market orders
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
if(ask <= 0 || bid <= 0)
{
Print(" Market prices unavailable, aborting order.");
return false;
}
double price = (type == ORDER_TYPE_BUY) ? ask : bid;
// STOPLOSS based on reference candle as requested:
// Longs: SL = refLow - StopLossPips * pip
// Shorts: SL = refHigh + StopLossPips * pip
if(type == ORDER_TYPE_BUY)
{
sl = refLow - StopLossPips * pip;
tp = price + (price - sl) * TakeProfitMultiplier;
}
else
{
sl = refHigh + StopLossPips * pip;
tp = price - (sl - price) * TakeProfitMultiplier;
}
lot = (UsePercentRisk) ? CalculateLotByRisk(sl, price) : LotSize;
lot = NormalizeLotToStep(_Symbol, lot);
MqlTradeRequest req;
MqlTradeResult res;
ZeroMemory(req);
ZeroMemory(res);
req.action = TRADE_ACTION_DEAL;
req.magic = MagicNumber;
req.symbol = _Symbol;
req.volume = lot;
req.type = type;
req.price = price;
req.sl = sl;
req.tp = tp;
req.deviation = 20;
req.type_filling = ORDER_FILLING_IOC;
// include trigger info in comment for traceability
string tstr = TimeToString(triggerTime, TIME_DATE|TIME_SECONDS);
req.comment = StringFormat("FollowCandle trg:%s open:%.5f", tstr, triggerOpen);
bool success = OrderSend(req, res);
if(!success)
{
PrintFormat(" OrderSend failed. retcode=%d; order=%I64u; comment=%s", res.retcode, res.order, res.comment);
return false;
}
// Confirm position existence (best-effort)
if(res.order > 0)
{
Sleep(100);
int total = PositionsTotal();
for(int i=0; i<total; i++)
{
ulong ticket = PositionGetTicket(i);
if(ticket == 0) continue;
if(PositionSelectByTicket(ticket))
{
string psym = PositionGetString(POSITION_SYMBOL);
long pmagic = PositionGetInteger(POSITION_MAGIC);
if(StringCompare(psym, _Symbol) == 0 && pmagic == MagicNumber)
{
tradeOpened = true;
PrintFormat(" %s trade opened | Price=%.5f | SL=%.5f | TP=%.5f | Lots=%.2f | Order=%I64u | Trigger=%s",
(type==ORDER_TYPE_BUY)?"BUY":"SELL", price, sl, tp, lot, ticket, tstr);
return true;
}
}
}
// fallback: mark opened if order accepted
tradeOpened = true;
PrintFormat(" Order accepted (order=%I64u) but position not found immediately. retcode=%d; comment=%s",
res.order, res.retcode, res.comment);
return true;
}
PrintFormat(" OrderSend returned no order id. retcode=%d; comment=%s", res.retcode, res.comment);
return false;
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
MqlDateTime current;
TimeToStruct(TimeCurrent(), current);
// Reset on new day
if(current.day != lastTradeDay)
{
referenceSet = false;
tradeOpened = false;
refCandleTime = 0;
lastTradeDay = current.day;
}
// Parse user-specified start time robustly
int startHour = 0, startMin = 0;
ParseStartTime(TradeStartTime, startHour, startMin);
// Build today's reference candle expected time (server time)
datetime todayStart = StructToTime(current);
todayStart -= (current.hour*3600 + current.min*60 + current.sec);
todayStart += startHour*3600 + startMin*60;
// Wait until reference candle exists and has closed
if(!referenceSet)
{
datetime refCandleExpected = todayStart;
if(TimeCurrent() >= refCandleExpected + PeriodSeconds(Timeframe))
{
int refShift = iBarShift(_Symbol, Timeframe, refCandleExpected, false);
if(refShift >= 0)
{
datetime barTime = iTime(_Symbol, Timeframe, refShift);
if(barTime == refCandleExpected || MathAbs((long)(barTime - refCandleExpected)) <= PeriodSeconds(Timeframe))
{
refOpen = iOpen(_Symbol, Timeframe, refShift);
refHigh = iHigh(_Symbol, Timeframe, refShift);
refLow = iLow(_Symbol, Timeframe, refShift);
refClose = iClose(_Symbol, Timeframe, refShift);
refCandleTime = barTime;
referenceSet = true;
PrintFormat(" Reference candle set at %s | High=%.5f | Low=%.5f | Open=%.5f | Close=%.5f",
TimeToString(refCandleTime), refHigh, refLow, refOpen, refClose);
}
else
{
// tolerant fallback
refOpen = iOpen(_Symbol, Timeframe, refShift);
refHigh = iHigh(_Symbol, Timeframe, refShift);
refLow = iLow(_Symbol, Timeframe, refShift);
refClose = iClose(_Symbol, Timeframe, refShift);
refCandleTime = barTime;
referenceSet = true;
PrintFormat(" Using nearest closed candle at %s as reference (expected %s).", TimeToString(barTime), TimeToString(refCandleExpected));
}
}
else
{
return;
}
}
else
{
return;
}
}
// Wait for trigger candle to CLOSE beyond reference
if(referenceSet && !tradeOpened)
{
if(Bars(_Symbol, Timeframe) < 3)
return;
int triggerShift = 2; // fully closed candle (2 ago)
double triggerClose = iClose(_Symbol, Timeframe, triggerShift);
double triggerOpen = iOpen(_Symbol, Timeframe, triggerShift);
datetime triggerTime = iTime(_Symbol, Timeframe, triggerShift);
// Breakout up
if(triggerClose > refHigh)
{
PrintFormat(" Trigger candle closed above reference high. Trigger time=%s Open=%.5f Close=%.5f RefHigh=%.5f",
TimeToString(triggerTime), triggerOpen, triggerClose, refHigh);
if(UseMarketEntry)
{
if(OpenTradeAtPrice(ORDER_TYPE_BUY, triggerOpen, triggerTime))
tradeOpened = true;
}
else
{
if(OpenTradeAtPrice(ORDER_TYPE_BUY, triggerOpen, triggerTime))
tradeOpened = true;
}
}
// Breakout down
else if(triggerClose < refLow)
{
PrintFormat(" Trigger candle closed below reference low. Trigger time=%s Open=%.5f Close=%.5f RefLow=%.5f",
TimeToString(triggerTime), triggerOpen, triggerClose, refLow);
if(UseMarketEntry)
{
if(OpenTradeAtPrice(ORDER_TYPE_SELL, triggerOpen, triggerTime))
tradeOpened = true;
}
else
{
if(OpenTradeAtPrice(ORDER_TYPE_SELL, triggerOpen, triggerTime))
tradeOpened = true;
}
}
}
}
//+------------------------------------------------------------------+