Expert Advisor Development — Your Strategy as an MQL4 / MQL5 Robot
We turn a written trading strategy into a tested, documented Expert Advisor for MetaTrader 4 or 5: risk-based position sizing, safe order handling, Strategy Tester reports and full source code that belongs to you.
An Expert Advisor (EA) is a program written in MQL4 or MQL5 that runs inside MetaTrader and trades automatically by your rules. ExpertNevees builds custom EAs from your strategy description — including risk management, trailing stops, news and session filters — backtests them in the MetaTrader Strategy Tester, and delivers a compiled file plus full source code, documentation and 6 months of support. Typical delivery is 7–14 days depending on complexity.
What Is Included in an Expert Advisor Project
Strategy → exact specification
Clean, commented MQL code
.mq5 / .mq4 source with named inputs, so you or another developer can maintain it later.Built-in risk controls
Backtest report
Documentation
Post-delivery support
Anatomy of a Professional Expert Advisor
Signal Layer
Risk Layer
Execution Layer
Safety Layer
Should You Choose MQL4 (MT4) or MQL5 (MT5)?
| MetaTrader 4 (MQL4) | MetaTrader 5 (MQL5) | |
|---|---|---|
| Language | Procedural, C-like | Object-oriented, C++-like (classes, inheritance) |
| Account model | Hedging only: many independent orders | Netting or hedging depending on the broker’s account type |
| Strategy Tester | Single-threaded, bar-model tester | Multi-threaded, real-tick history, forward testing, cloud agents |
| Timeframes | 9 standard timeframes | 21 timeframes |
| Machine learning | Not supported natively | ONNX model execution inside the EA |
| Our recommendation | Choose it if your broker or an existing EA is MT4-only | Recommended for new projects |
We develop for both platforms and can deliver the same strategy for MT4 and MT5 when needed. See the full language guide: MQL4 / MQL5 guide.
How We Structure Risk-Based Position Sizing in MQL5
// Volatility-adjusted stop and risk-percent lot sizing (strategy signal intentionally left as a stub)
#include <Trade\Trade.mqh>
CTrade trade;
input double RiskPercent = 1.0; // risk per trade, % of balance
input int AtrPeriod = 14;
input double AtrSlMult = 1.5; // stop distance = ATR x multiplier
input ulong MagicNumber = 240901;
int atrHandle = INVALID_HANDLE;
datetime lastBar = 0;
int OnInit()
{
trade.SetExpertMagicNumber(MagicNumber);
atrHandle = iATR(_Symbol, PERIOD_CURRENT, AtrPeriod);
return (atrHandle == INVALID_HANDLE) ? INIT_FAILED : INIT_SUCCEEDED;
}
void OnDeinit(const int reason) { IndicatorRelease(atrHandle); }
bool IsNewBar()
{
datetime t = iTime(_Symbol, PERIOD_CURRENT, 0);
if(t == lastBar) return false;
lastBar = t;
return true;
}
bool HasOpenPosition()
{
for(int i = PositionsTotal() - 1; i >= 0; i--)
if(PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_MAGIC) == (long)MagicNumber)
return true;
return false;
}
double LotsForRisk(double slDistance)
{
double riskMoney = AccountInfoDouble(ACCOUNT_BALANCE) * RiskPercent / 100.0;
double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
double lossPerLot = slDistance / tickSize * tickValue;
if(lossPerLot <= 0.0) return 0.0;
double step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
double lots = MathFloor(riskMoney / lossPerLot / step) * step;
if(lots < SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN)) return 0.0; // risk too small for the minimum lot
return MathMin(lots, SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX));
}
int SignalDirection() { return 0; } // +1 buy, -1 sell, 0 none: your strategy goes here
void OnTick()
{
if(!IsNewBar() || HasOpenPosition()) return;
double atr[];
if(CopyBuffer(atrHandle, 0, 1, 1, atr) != 1) return; // last closed bar
int dir = SignalDirection();
if(dir == 0) return;
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
double dist = atr[0] * AtrSlMult;
double lots = LotsForRisk(dist);
if(lots <= 0.0) return;
bool ok = (dir > 0) ? trade.Buy(lots, _Symbol, ask, ask - dist, ask + 2 * dist)
: trade.Sell(lots, _Symbol, bid, bid + dist, bid - 2 * dist);
if(!ok)
PrintFormat("Order failed: retcode=%u (%s)", trade.ResultRetcode(), trade.ResultRetcodeDescription());
}
This is a teaching skeleton, not a trading strategy. Production EAs add spread and session filters, broker stop-level checks, partial closes, logging and state recovery after a terminal restart.
How an EA Project Works, Step by Step
Send your strategy
Describe the rules in your own words, or send a PDF, screenshots or an existing indicator. The more precise the input, the closer the result is to your vision.
Feasibility review and specification
We review technical constraints, resolve every ambiguity (what counts as a signal, when is a trade closed, what happens on a gap) and send back a written specification.
Price and timeline
You receive a fixed price and delivery date in writing. No hidden costs or mid-project price changes.
50% advance, development starts
Work begins after the advance payment.
Test build and backtest report
You receive a compiled test version with a Strategy Tester report for your symbols and timeframes.
Your testing and revisions
Test on demo or live. Revisions needed to match the agreed specification are applied at no extra cost.
Approval, final payment and handover
After your approval you pay the remaining 50% and receive the final file, full source code, documentation and installation guide.
Where Most Home-Made and Marketplace EAs Fail
- ●Lot size ignores the stop-loss: a fixed lot gives wildly different risk per trade. We size every trade from risk percent and stop distance.
- ●Order results are never checked: an unchecked failed order (invalid stops, market closed, no money) silently breaks the strategy. Every request’s return code is verified and logged.
- ●Backtest uses unrealistic conditions: zero spread, no commission and perfect fills overstate results. We test with realistic spread, commission and slippage.
- ●Over-optimized parameters: parameters tuned to one period collapse live. We validate out-of-sample and with forward tests. See Backtesting & Optimization.
- ●No restart recovery: an EA that forgets its state after a VPS reboot can double-enter or abandon trades. State is rebuilt from open positions and the magic number.
- ●Hidden martingale or grid risk: we flag strategies whose risk grows without limit and add hard caps so the account is not exposed to ruin by design.
What We Need From You to Start
- ●The strategy rules: entry, exit, stop-loss, take-profit, filters and what must never happen.
- ●Platform and broker type: MT4 or MT5, hedging or netting, symbols and timeframes.
- ●Risk preferences: risk per trade, maximum drawdown you accept, maximum simultaneous trades.
- ●Any reference material: indicator files, screenshots of example trades, or a past trade list.
Delivery, Support & Guarantee
Timelines are indicative. The exact price and delivery date are confirmed in writing before work starts, with no hidden costs. Payment: 50% advance, 50% after your approval (USDT or bank wire).
Frequently Asked Questions
How much does Expert Advisor development cost?
Every EA is priced by scope: number of entry and exit rules, filters, money-management features, platform (MT4, MT5 or both) and testing requirements. You receive a fixed written quote after the free feasibility review, before any payment.
How long does it take to build an Expert Advisor?
A full custom EA with risk management typically takes 7–14 days. Simple tools take less, and complex multi-symbol or multi-timeframe systems take longer. The exact date is confirmed before work starts.
Do I get the source code?
Yes. Every project is delivered with the compiled file and the complete, commented source code, with no locks or restrictions. The code is yours.
Can you code my strategy for both MT4 and MT5?
Yes. We develop in MQL4 and MQL5 and can deliver the same strategy on both platforms. MT5 is recommended for new projects because of its stronger Strategy Tester and ONNX support.
Will the EA be profitable?
No developer can honestly guarantee profits. We guarantee that the EA behaves exactly as specified: a 30-day technical guarantee means defects against the agreed specification are fixed for free. Profitability depends on the strategy and on market conditions.
Can I test the EA before the final payment?
Yes. You receive a test build and a backtest report first, test it on your own demo or live account, and pay the remaining 50% only after you approve it.
Can the EA send Telegram or WhatsApp notifications?
Yes. Trade alerts and daily summaries can be sent to Telegram, and to WhatsApp through its official business API. See Signal Bot Development.
Can you fix or improve an EA that someone else wrote?
Yes. We debug and extend existing code. See Trading Bot Bug Fixing.
Official Documentation & Sources
- MQL5 Reference — Official Language DocumentationMQL5.comView Docs ↗
- Strategy Tester — MetaTrader 5 HelpMetaTrader5.comView Docs ↗
Ready to Turn Your Strategy Into an Expert Advisor?
Send your strategy on Telegram or use the contact form. The initial consultation and feasibility review are free.