MetaTrader 4 Automation: Building and Testing Expert Advisors

MetaTrader 4 Automation: Building and Testing Expert Advisors

Key Takeaways

  • Automating trading on MetaTrader 4 (MT4) speeds execution, enforces discipline, and enables systematic, repeatable strategies through Expert Advisors (EAs).
  • The MT4 Strategy Tester is essential: it lets you backtest EAs with historical data, compare modelling qualities (Every Tick, Control Points, Open Prices), and run optimizations.
  • Good EA development needs clean historical tick data, disciplined MQL4 code structure, iterative backtest→optimize→forward-test cycles, and walk-forward thinking to avoid overfitting.
  • Focus on metrics (equity curve shape, profit factor, max drawdown, expected payoff) and practical risk controls (lot sizing, slippage, commissions) before going live.
  • Deliverables to target: a reliable sample .mq4 skeleton, reproducible tester presets, and a demo-forward testing plan with VPS/monitoring for live migration.

Table of Contents

Why Automate Trading on MT4?

Automating your trading with an MT4 Expert Advisor (EA) turns a discretionary idea into a reproducible system. For many traders, automation is not a magic bullet — it’s a tool that enforces rules, removes emotional errors, and allows you to run objective experiments at scale.

First, automation accelerates execution. Human reaction times and manual order entry introduce slippage and missed opportunities, especially for scalping or intraday strategies. An EA executes exactly as coded, placing orders, modifying stops and trailing, and managing exits with consistent timing.

Second, automation forces clarity. To convert an idea into an EA you must define precise entry, exit, and risk rules. That discipline improves strategy quality: vague guidelines become concrete checks (e.g., “enter when 20 EMA crosses above 50 EMA and RSI(14) > 50”). Clear rules are testable and optimizable.

Third, automation enables exhaustive testing. Backtesting MT4 lets you run thousands of trade simulations across long historical intervals and multiple instruments. Combined with optimization, you can find parameter regions that are robust rather than just lucky.

Who should automate on MT4?

  • Developers and technically minded traders comfortable with MQL4 who want tight integration with MetaTrader’s environment.
  • Systematic traders who value repeatability and the ability to iterate quickly.
  • Portfolio managers or prop traders who need EAs for execution consistency and monitoring.

Common use cases include trend-following systems, breakout traps, mean reversion scalpers, and risk-management utilities (automated trailing, position-sizers). MT4 remains popular because of its lightweight platform, mature Strategy Tester, and widespread broker support — a practical choice for many retail and semi-professional developers.

However, automation isn’t without cost: coding errors, poor data, and overfitting can produce realistic-looking backtests that fail in live trading. That’s why the Strategy Tester and a disciplined development process (build → backtest → optimize → forward test → deploy) are non-negotiable.

What Is The MT4 Strategy Tester And Why You Need It

The MT4 Strategy Tester is the built-in backtesting and optimization engine inside the MetaTrader 4 terminal. It simulates how an Expert Advisor would have traded on historical price data and allows you to measure performance using a set of standard metrics (net profit, drawdown, profit factor, number of trades, etc.). You can run single backtests, multi-pass optimizations, and visual (replay) tests to inspect trade-by-trade behavior.

Why it matters:

  • Rapid iteration. The Strategy Tester turns ideas into data quickly. A new EA can be compiled and tested across months or years of history in minutes or hours (depending on modelling quality).
  • Modeling quality choices. MT4 offers different modelling types — Every Tick, Control Points, and Open Prices Only — which trade off speed versus realism. Every Tick is the most accurate (simulates each tick) but slower; Open Prices trades on bar opens and is faster but less granular. Understanding these modes is essential for reliable conclusions.
  • Optimization tools. The tester supports parameter optimization (including genetic search) to explore parameter space. Combined with careful validation, optimization helps find robust parameter sets.
  • Visualization and diagnostics. The Graph tab (equity curve), Report tab (performance metrics), and Trade List allow you to diagnose behavior: streaks, clustered losses, commission sensitivity, and slippage impacts.

What it doesn’t replace:

  • Live/forward testing. Backtests are conditional on historical data and assumptions. Demo forward testing against a live price feed is the next step to confirm real-world behavior.
  • Good data / careful methodology. Poor tick data, unrealistic spread/commission assumptions, or aggressive optimization lead to misleading results. The Strategy Tester is a tool; proper use and critical analysis make it effective.

In short, if you plan to build MT4 Expert Advisors, mastering the Strategy Tester is as important as writing clear MQL4 code. It’s the feedback loop that tells you whether your strategy idea is worth moving toward a live environment.

Preparing To Build An EA: Requirements And Tools

Before writing your first Expert Advisor, create a stable development environment and collect the necessary data. This saves debugging time and reduces false starts.

Software and Platform Setup

  • Install the latest reliable MT4 terminal (choose your broker or a clean demo broker).
  • Use an editor for MQL4 development — MetaEditor (built into MT4) is sufficient; advanced users often prefer Notepad++ or Visual Studio Code with MQL4 plugins for syntax highlighting.
  • Configure logs: set Experts and Journal logging in MT4 so you can trace EA behavior.
  • Optionally set up a version control workflow (Git + local repo) for EA source code.

Quick checklist:

  • MT4 terminal installed and updated
  • MetaEditor or preferred editor configured
  • Demo account + VPS access plan (if forward testing remotely)
  • Folder for historical tick data and test presets

Historical Data: Quality, Sources, and Importing

Backtest credibility hinges on the tick/price data:

  • Preferred: high-resolution tick data (1-tick) from reliable providers or your broker’s own tick history. This yields the most realistic Every Tick simulations.
  • Acceptable for many strategies: high-quality 1-minute data converted to ticks (using tools like Tickstory — note: consider third-party utility limitations).
  • Avoid: sparse or truncated data from cheap sources — gaps and inconsistent spreads will bias results.

Importing tips:

  • Use MT4’s History Center (F2) to view and import data. For high-quality tick use, external tools may be needed to load .csv tick dumps into MT4-compatible format.
  • Keep a separate folder with original data snapshots so you can reproduce tests later.

MQL4 Basics: Files, Functions, and Structure

MQL4 code for an EA typically lives in files with .mq4 extension. A minimal EA has three lifecycle functions:

  • OnInit() — one-time initialization (load indicators, set variables).
  • OnTick() — called on every incoming tick (main trading logic).
  • OnDeinit() — cleanup on unload (save state, free resources).

Other common elements:

  • Global input parameters (input double Lots = 0.1;), which become Expert Properties in the Strategy Tester.
  • Order management wrappers for OrderSend, OrderClose, OrderModify with error handling and logging.
  • Use Print() for text logs and Comment() for in-terminal overlays during visual testing.

Quick commands and tips:

  • Compile often in MetaEditor to catch syntax and type errors.
  • Use #property strict at the top of code to enforce cleaner MQL4 rules.
  • Keep functions small: CalculateEntry(), OpenPosition(), ManagePosition() improve readability and testability.

Step-By-Step: Building Your First MT4 Expert Advisor

Building MT4 Expert Advisor

This section walks you from concept to a working EA skeleton.

Define Strategy and Rules (Entry, Exit, Risk)

Start with a concise strategy statement:

  • Example: “Enter long when 20-period EMA crosses above 50-period EMA and RSI(14) < 70. Exit on a 2x ATR trailing stop or 10% account drawdown.”
    Define risk per trade (e.g., 1% of account equity) and order sizing rules (fixed lots vs. percent risk). Clearly list hard stops and trade management rules.

Checklist:

  • Entry conditions (technical triggers + filters)
  • Stop-loss and take-profit rules (ATR-based or fixed pip)
  • Position sizing method (fixed or risk % of equity)
  • Session/time filters and instrument whitelist

EA Skeleton: OnInit, OnTick, OnDeinit Explained

Below is a minimal EA skeleton you can expand:

//+——————————————————————+
//| SimpleEA.mq4                                                     |
//+——————————————————————+
#property strict
input double Lots = 0.1;
input int FastEMA = 20;
input int SlowEMA = 50;
input int RSIperiod = 14;
input double RiskPercent = 1.0;
int OnInit()
  {
   // Initialize indicators, variables
   Print(“SimpleEA initialized”);
   return(INIT_SUCCEEDED);
  }
void OnDeinit(const int reason)
  {
   // Cleanup
   Print(“SimpleEA deinitialized”);
  }
void OnTick()
  {
   double fast = iMA(NULL,0,FastEMA,0,MODE_EMA,PRICE_CLOSE,0);
   double slow = iMA(NULL,0,SlowEMA,0,MODE_EMA,PRICE_CLOSE,0);
   double rsi  = iRSI(NULL,0,RSIperiod,PRICE_CLOSE,0);
   // Entry logic
   if(fast > slow && rsi < 70)
     {
      // Risk and order sizing logic here
      if(OrdersTotal() == 0)
         OpenBuy();
     }
  }
void OpenBuy()
  {
   double price = NormalizeDouble(Ask,Digits);
   double sl = price – 50*Point; // example fixed SL
   double tp = price + 100*Point; // example fixed TP
   int ticket = OrderSend(Symbol(),OP_BUY,Lots,price,3,sl,tp,”SimpleEA”,0,0,clrGreen);
   if(ticket < 0) Print(“OrderSend failed: “,GetLastError());
  }

This minimal EA shows indicator pulls and a simplified order send. In production, replace fixed SL/TP with ATR-based sizing and add robust order checks.

Common MQL4 Code Snippets

Order send with dynamic lot sizing:

double CalculateLotSize(double riskPercent)

  {

   double riskAmount = AccountBalance() * riskPercent / 100.0;

   double stopLossPips = 50; // example

   double riskPerLot = stopLossPips * Point * 10; // pip value approx

   double lots = riskAmount / riskPerLot;

   return(NormalizeDouble(lots,2));

  }

Trailing stop example:

void TrailingStop()

  {

   for(int i=0;i<OrdersTotal();i++)

     {

      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))

        {

         if(OrderType()==OP_BUY)

           {

            double newSL = Bid – 30*Point;

            if(OrderStopLoss() < newSL)

               OrderModify(OrderTicket(),OrderOpenPrice(),newSL,OrderTakeProfit(),0,clrNone);

           }

        }

     }

  }

Testing Locally: Compiler, Logs, and Debugging Tips

  • Compile (F7) frequently. Warnings are early signs of logic problems.
  • Use Print() liberally but avoid printing in hot loops — excessive logs slow the terminal.
  • For complex bugs, instrument code with trade-state logs: PrintFormat(“Trade opened: ticket=%d price=%f sl=%f”,ticket,price,sl);
  • Use Visual Mode in the Strategy Tester to replay trades and inspect behavior (see later section).
  • Maintain test presets: save Expert Properties to .set files so you can reproduce results.

Setting Up The MT4 Strategy Tester

The Strategy Tester dialog is a compact UI but each field matters. Below are the core settings and practical recommendations:

Expert Advisor (EA) Selection

Choose the compiled .ex4 or .mq4 EA. Keep versions tidy: name files with version numbers. Save .set presets for parameter combinations you test frequently.

Symbol (Choosing Pairs & Synthetic Instruments)

Pick symbols that match your strategy’s domain (EURUSD for FX scalping; XAUUSD for gold strategies). Be aware that some brokers have synthetic symbols (e.g., EURUSDx) with different spreads — use the exact symbol available in your terminal.

Modelling Quality (Every Tick vs Open Price etc.)

  • Every Tick: Simulates true tick movement; best for precision and for strategies sensitive to order execution and stops. Use when fidelity matters.
  • Control Points: A compromise; faster than Every Tick, more detailed than Open Prices.
  • Open Prices Only: Fastest, suitable for strategies that only evaluate on bar opens (e.g., daily-bar systems).
    Always match modelling choice to your strategy’s tick-sensitivity.

Period (Timeframe)

Select timeframe matching your EA’s logic (M1, M5, H1, D1). For multi-timeframe EAs, backtest using the smallest timeframe used by the EA for realism.

Spread Settings (Fixed vs. Real)

Set realistic spreads:

  • Use average spread for target account type, or select “Use Current Spread” for demo parity.
  • For scalpers, small spread changes impact P/L heavily — test sensitivity (e.g., 0.5x, 1x, 1.5x spreads).

Date Range (Why Long Sample Windows Matter)

Long samples reduce variance: test at least multiple years covering different market regimes. Include crisis periods (high volatility, low liquidity) if the EA will trade through them.

Optimization Process (Genetic vs Brute Force)

  • Brute Force: exhaustive but heavy on time/resources.
  • Genetic Algorithm: searches efficiently for promising parameter areas; faster but risk of local minima.
    After optimization, validate best parameter sets on out-of-sample data.

Expert Properties (Inputs, Parameters, Presets)

Inputs become properties exposed in the tester. Document and annotate each input in code (input string Note = “…”) to keep clarity. Save .set presets for reproducibility.

Visualisation Mode (Pros & Cons)

Visual mode draws trades on the chart — great for manual inspection and finding logic errors. It’s slower; use for debugging and occasional verification rather than mass backtesting.

Deposit, Lot Sizing, Slippage, and Comments

Set initial deposit and currency type to match target account. Factor in slippage (set in Tester) because simulated execution assumes immediate fills unless slippage parameter is used. Use “Comments” input to tag runs for future reference (e.g., v1.2-ATR20).

Quick screenshot recommendations: capture Strategy Tester dialog showing all settings, a Graph tab with equity curve, and the Report tab with key metrics. Annotate images showing chosen modelling type, date range, and spread settings.

Running Backtests: Walkthrough And Best Practices

A disciplined backtesting workflow yields reliable insights.

Single Backtest Vs Optimization Runs

  • Single backtest: Use for debugging, initial behavior check, and measuring baseline performance.
  • Optimization runs: Use to discover parameter regions. Start with broad ranges and coarse steps, then refine with narrower ranges and finer steps.

Using Tick Data For Higher Accuracy

For tick-sensitive strategies, convert high-quality tick data into MT4-compatible format and run Every Tick modelling. Validate tick data coverage (no gaps), especially around weekends and holidays.

Warm-up Periods, Walk-Forward Windows, and Overfitting Avoidance

  • Warm-up periods: Some indicators (e.g., multi-period EMAs) need initialization — exclude early portion of a backtest until indicators settle.
  • Walk-forward testing: Partition data into optimization (in-sample) and validation (out-of-sample) windows. Optimize on in-sample, test on out-of-sample, then roll forward. This mimics forward evolution and combats curve fitting.
  • Avoiding overfitting: Limit the number of parameters you optimize simultaneously; prefer stable parameter regions over single best-fit numbers. Use robustness checks: parameter sensitivity scans and Monte Carlo simulations (randomized slippage/spread).

Procedural checklist:

  1. Run initial single backtest (Open Prices or Control Points) to confirm logic.
  2. Use Every Tick for final precision if EA is tick-sensitive.
  3. Run initial optimization with wide ranges (genetic) to find candidate zones.
  4. Narrow search and run brute force around candidate zones.
  5. Validate top candidates on an out-of-sample period (walk-forward).
  6. Forward test on a demo account for several weeks/months before live migration.

Analysing Test Results In MT4

Raw numbers alone deceive; understanding what metrics mean and how they interrelate is essential.

Interpreting The Graph Tab (Equity Curve Signals)

The equity curve (Graph) shows cumulative profit. Look for:

  • Smooth upward trend with small steady drawdowns (ideal).
  • Large equity spikes followed by deep drawdowns (risky, likely curve-fitted).
  • Frequent flat sections may signal low edge or parameter dependency.

Reviewing The Report Tab (Metrics: Profit Factor, Drawdown, Trades)

Key metrics and reasonable threshold guidelines (use as a starting point, not iron rules):

MetricWhat It MeansPractical Thresholds
Net ProfitTotal monetary gainPositive and consistent across samples
Profit FactorGross profit / gross loss> 1.5 acceptable; > 2 preferred
Max Drawdown (absolute)Largest equity dropDepends on strategy; keep ≤ 20% for aggressive; ≤ 10% for conservative
Recovery FactorNet profit / Max drawdownHigher is better; > 1.5 desirable
Expected PayoffAverage profit per tradePositive and stable
Number of TradesSample size for reliability> 200 trades for statistical significance

Use the Report tab to compare how parameter changes affect these values. Beware of over-optimized metrics with few trades.

Trade List & Journal: What To Look For (Clustered Losses, Spread/Commission Hits)

Export the trade list and inspect:

  • Time clustering of losses (market regime sensitivity).
  • Correlation with economic events or low-liquidity times.
  • Spread and commission effects — if commissions turn a profitable strategy into a loss, adjust business case.

Exporting Results and Integrating With Excel/CSV

Use the Report tab to save results; export trade lists to CSV for deeper analysis:

  • Plot rolling Sharpe, drawdown timelines, and trade-by-trade returns.
  • Run simple Monte Carlo (shuffle trades) to estimate potential P/L variability under random order sequences.

Forward Testing And Demo To Live Migration

Backtests are only the start. Forward testing confirms if the edge survives live market microstructure.

Demo / Forward Testing Setup (Real Market Conditions)

  • Use a demo account with the same broker and server as intended live.
  • Apply the same spreads and commission structure. If the broker’s demo has artificially low spreads, consider a live but small-funded account for final validation.
  • Run the EA for a minimum period covering multiple market regimes (ideally a few months, depending on strategy frequency).

Checklist:

  • Demo account with matched spreads/commissions
  • Realistic starting deposit and lot sizes
  • Monitoring/logging enabled for all orders and errors

VPS, Latency And Execution Differences

Latency and execution matter:

  • Host EA on a reputable VPS near your broker’s servers.
  • Monitor for requotes and slippage — some brokers implement execution policies that differ between demo and live (market vs instant execution).
  • If EA uses fast logic (scalping), reduce latency to avoid losses from delayed order fills.

Risk Controls And Monitoring Tools

  • Implement automatic daily/weekly max loss cutoffs in EA.
  • Add watchdog scripts to alert if EA hits unexpected error patterns (e.g., repeated ERR_TRADE_CONTEXT_BUSY).
  • Use remote logging (email, push notifications) for critical events.

Optimizing Expert Advisors — Practical Approaches

Optimization is a craft: it searches useful parameter space while avoiding the siren song of perfect backtest results.

Parameter Sensitivity (Parameter Stability Tests)

After finding a “best” parameter set, run sensitivity scans:

  • Vary one parameter at a time ±10–30% to observe metric stability.
  • Parameters whose small changes lead to large performance swings indicate fragility.

Example: If ATR-period 14 yields the best result but ATR 12 or 16 collapses P/L, that parameter is unstable and suspect.

Walk-Forward Optimization (Concept + How To Approximate in MT4)

Walk-forward approximates true forward performance:

  1. Split data into an in-sample window and out-of-sample window.
  2. Optimize on in-sample.
  3. Test best parameters on out-of-sample.
  4. Roll the window forward and repeat.

In MT4, you can emulate walk-forward manually by saving optimized sets and testing sequentially across successive time slices.

Avoiding Curve Fitting (Rules & Heuristics)

  • Limit the number of optimized parameters (the fewer, the better).
  • Prefer simpler rules with economic rationale over black-box parameter combinations.
  • Require robustness across multiple instruments and timeframes.
  • Look for parameter clusters (wide plateaus of good performance) rather than narrow spikes.

Brief example of stable vs unstable parameter:

  • Stable: EMA crossover with stop = ATR(14) × k, where k between 1.5 and 2.5 yields similar profit.
  • Unstable: A 7-indicator composite with 12 tunable thresholds that performs well only at a single few-digit combination — likely overfit.

Common Issues, Troubleshooting And FAQs

The Strategy Tester and EAs are robust, but common problems recur.

Typical MT4 Strategy Tester Problems (Data Gaps, Incorrect Ticks)

  • Symptom: Sudden unrealistic equity spikes or zero trades.
    Fix: Check history center for gaps; re-import tick data or use Every Tick with verified tick source.
  • Symptom: Missing fills or slippage discrepancies.
    Fix: Set slippage parameters and simulate higher spreads; check broker execution policy.

EA Crashes, Infinite Loops, and Memory Issues

  • Infinite loops: Always include exit conditions in loops. Use counters and safety breaks.
  • Memory leaks: Free handles and objects; avoid dynamic arrays without bounds.
  • Crashes: Check GetLastError() after trade calls and log full context.

How To Verify Order Execution Logic (Replay/Visual Mode Tips)

  • Run Visual Mode for a portion of data and step through trades.
  • Add Comment() outputs to show current state variables on the chart during visual tests.
  • Save trade lists and cross-check open/close times with chart events.

Quick fixes list

  • Re-check symbol name and contract specs (point size, digits).
  • Re-compile EA after changing input types.
  • Use strict typing and defensive null-checks around indicator calls.

Top MT4 Strategies To Automate (Short Walkthroughs)

Below are practical mini-guides for four strategy families that map well to EAs.

Trend Following Strategy

  • Core idea: Ride persistent moves; cut losers short.
  • Entry: EMA(20) crosses above EMA(50) with volume/ATR filter.
  • Exit: ATR-based trailing stop or momentum loss.
  • EA considerations: Position sizing by equity %, trend filters to avoid choppy ranges, strict stop discipline, low-frequency to reduce transaction costs.

Breakout Strategy

  • Core idea: Enter when price breaks a well-defined range or level.
  • Entry: Break above recent swing high with volume/volatility confirmation.
  • Exit: Take profit at measured move distance or use trailing stop after breakout proves itself.
  • EA considerations: False-breakout filters (e.g., require X candles above breakout or retest confirmation), spread sensitivity, and news-time avoidance.

Range Trading Strategy

  • Core idea: Buy near support, sell near resistance in low-volatility ranges.
  • Entry: Oscillator readings (RSI overbought/oversold) near bounds; confirmation via price action.
  • Exit: Close near mid-range or on opposite oscillator extreme.
  • EA considerations: Position sizing must account for lower frequency of trades; avoid automating range strategies during breakout periods — add regime detection.

Carry Trade Considerations

  • Core idea: Benefit from interest-rate differentials while managing FX risk.
  • Entry: Long currencies with higher positive swap; short currencies with negative swap exposure carefully.
  • EA considerations: Swaps and rollover impact P/L; test across long timeframes to capture swap variability and rate changes. Include overnight holding risk controls.

Using MT4 Tools To Enhance Your EAs

MT4 is more than Strategy Tester + Editor; auxiliary tools raise the quality of your automation.

Indicators And Custom Indicators Integration

  • Custom indicators (.ex4) can be called via iCustom() from EAs. Ensure their buffers and indexing are well-documented.
  • Wrap iCustom() calls with validity checks to avoid false signals during indicator initialization.

Using Scripts And Utilities (Data Exporters, Testers)

  • Use scripts to export trade history, snapshot data, or to batch-run tests.
  • Third-party utilities help import tick data, run walk-forward automatisms, and generate visual analytics.

Third-party Libraries, DLLs & Safety Considerations

  • DLLs extend functionality but break portability and compliance; avoid unless necessary.
  • Keep security in mind: do not run untrusted compiled code on live accounts. Review third-party code or prefer open-source libraries you can audit.

Code Appendix & Downloadable Resources

Below is an expanded simple EA example for educational use (copy/paste into MetaEditor and compile). This is a starter skeleton — adapt parameters, risk logic, and error handling for production use.

//+——————————————————————+

//| StarterEA.mq4                                                    |

//+——————————————————————+

#property strict

input double   RiskPercent = 1.0;

input int      FastEMA = 20;

input int      SlowEMA = 50;

input int      RSIperiod = 14;

input double   ATRmult = 1.5;

input int      ATRperiod = 14;

int OnInit()

  {

   Print(“StarterEA v1.0 initialized”);

   return(INIT_SUCCEEDED);

  }

void OnDeinit(const int reason)

  {

   Print(“StarterEA deinitialized”);

  }

void OnTick()

  {

   if(IsTradeAllowed() == false) return;

   double fast = iMA(NULL,0,FastEMA,0,MODE_EMA,PRICE_CLOSE,0);

   double slow = iMA(NULL,0,SlowEMA,0,MODE_EMA,PRICE_CLOSE,0);

   double rsi  = iRSI(NULL,0,RSIperiod,PRICE_CLOSE,0);

   double atr  = iATR(NULL,0,ATRperiod,0);

   // Simple entry

   if(fast > slow && rsi < 70 && OrdersTotal()==0)

     {

      double sl = NormalizeDouble(Bid – ATRmult*atr,Digits);

      double lot = CalculateLotSize(RiskPercent,ATRmult*atr);

      int ticket = OrderSend(Symbol(),OP_BUY,lot,Ask,3,sl,0,”StarterEA”,0,0,clrBlue);

      if(ticket<0) Print(“OrderSend error: “,GetLastError());

     }

   // Example trailing

   TrailingStop();

  }

double CalculateLotSize(double riskPercent, double stopDistance)

  {

   double riskAmount = AccountBalance()*riskPercent/100.0;

   double tickValue = MarketInfo(Symbol(), MODE_TICKVALUE);

   if(tickValue == 0) tickValue = 1;

   double lots = riskAmount / (stopDistance / Point * tickValue);

   lots = MathMax(lots,0.01);

   return(NormalizeDouble(lots,2));

  }

void TrailingStop()

  {

   for(int i=0;i<OrdersTotal();i++)

     {

      if(OrderSelect(i,SELECT_BY_POS)==false) continue;

      if(OrderType()==OP_BUY)

        {

         double newSL = Bid – 0.5 * iATR(NULL,0,ATRperiod,0);

         if(newSL > OrderStopLoss())

            OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(newSL,Digits),OrderTakeProfit(),0,clrNone);

        }

     }

  }

Downloadables to prepare on your site:

  • starter-ea.mq4 (above)
  • sample-tick-data.zip (sample tick snippets for testing)
  • tester-presets.set (example Expert Properties file for common runs)

Conclusion

Building and testing MT4 Expert Advisors is a disciplined craft that combines coding, data hygiene, statistical testing, and practical risk management. Start with a clear trading idea, translate it into concise MQL4 rules, and use the MT4 Strategy Tester to iterate — but always validate with out-of-sample and forward demo testing. Pay attention to modelling quality, spreads/commissions, and parameter robustness: these are the difference between a promising backtest and a deployable live EA.

FAQ

How to use Strategy Tester in MT4?
Open MT4, press Ctrl+R or View → Strategy Tester. Select your Expert Advisor, symbol, timeframe, modelling type (Every Tick / Control Points / Open Prices), set the date range and initial deposit, and press Start. Use Visual Mode for step-through debugging and save Expert Properties as .set for reproducibility.

What is MT4 backtesting software?
MT4’s Strategy Tester is the built-in backtesting and optimisation environment for Expert Advisors written in MQL4. It simulates historical trading under chosen modelling assumptions and produces reports with standard metrics (net profit, drawdown, profit factor) and trade lists for analysis.

Is MT4 the best backtesting software?
“Best” depends on needs. MT4 is extremely accessible, broadly supported, and integrates seamlessly with MQL4 EAs. For ultra-high-frequency research, institutional tick-modeling, multi-asset portfolios, or advanced walk-forward automation, specialized platforms may be preferable. For many retail and semi-pro developers, MT4 is pragmatic and effective.

How accurate is the MT4 Strategy Tester?
Accuracy depends on inputs: modelling type and tick data are key. Every Tick modelling with high-quality tick data approximates real execution well; Open Prices modeling is faster but less precise. Also, realistic spreads, commission settings, and slippage parameters are crucial for believable results.

How do I avoid overfitting when optimizing an EA?
Use conservative optimization: limit parameters, prefer simple rules with economic rationale, validate on out-of-sample data (walk-forward), perform parameter sensitivity tests, and check performance across multiple instruments/timeframes. Look for plateaus of acceptable performance rather than single best points.

Can I run multiple EAs on one MT4 account?
Yes — you can attach multiple EAs to different charts under the same MT4 terminal and account, but they share account equity and margin. Ensure EAs coordinate risk (e.g., cumulative max drawdown limits) and avoid position-count conflicts. Consider separating critical strategies onto different accounts or sub-accounts for clearer risk management.