MT5 Expert Advisor Development: MQL5 Patterns and Tips (2026)

Quick answer. MT5 Expert Advisor development uses MQL5 (object-oriented, C++-style) to automate strategy execution inside MetaTrader 5. Production EAs need clean OnTick logic, position and risk management, broker filters (spread, slippage), validation in the multi-symbol Strategy Tester, and detailed logging. MT5 is required by most 2026 prop firms; budget $1,500-$6,000 for a custom EA.

When I first started developing Expert Advisors on MetaTrader 5, I made every mistake a developer can make. My EAs were slow, leaked memory, and crashed unexpectedly. I was treating MQL5 like JavaScript. That's not how it works.

Over years of building trading systems, I've developed specific patterns and practices that make MT5 EAs reliable, performant, and maintainable. This guide walks you through building production-quality EAs on MetaTrader 5 in 2026.

Why MT5 Still Matters

MetaTrader 5 isn't the newest platform, but it's still the most widely used for algorithmic trading. The ecosystem is mature, the brokers are numerous, and the tools are solid.

But MT5 development has peculiarities. If you come from other programming backgrounds, the learning curve is steep. MQL5 is object-oriented like C++, but it's not C++. It has quirks.

Understanding these quirks separates EAs that work from EAs that fail under stress.

Essential MT5 Architecture Patterns

Here's how I structure every EA I build:

Pattern 1: Separation of Concerns

I divide the EA into distinct components:

• Trade logic (signal generation)
• Risk management (position sizing, stops)
• Order management (execution, monitoring)
• Logging (tracking decisions)

Each component is a separate class. When something breaks, I know where to look.

Pattern 2: State Management

EAs must track state:

• Current position (open or closed?)
• Entry price and time
• Stop-loss level
• Previous bar's signal

I maintain a Position class that tracks this reliably. This prevents the common mistake of assuming the EA knows its state when restarted.

Pattern 3: Broker-Agnostic Code

Different brokers have different limitations:

• Spread size
• Order types (not all brokers support all order types)
• Slippage
• Commission

I abstract broker-specific details into a Broker class. This makes testing and switching brokers easier.

Pattern 4: Performance Optimization

MQL5 performance matters. The EA runs every tick. Slow code means missed trades.

I optimize:

• Indicator calculations (cache them if possible)
• String operations (expensive in MQL5)
• Database queries (batch them)
• Memory allocation (preallocate, don't dynamically allocate on every tick)

A slow EA is worse than no EA.

Core EA Components

Here's what every production EA includes:

OnInit(): Initialization

• Load configuration
• Initialize indicators
• Validate broker parameters
• Connect to database

OnStart(): Main logic (only used in scripts; not relevant for EA)

OnTick(): Runs every tick

• Update indicators
• Generate signals
• Check risk parameters
• Execute trades

OnDeinit(): Cleanup

• Close database connections
• Log final state
• Clean resources

OnTimer(): Periodic tasks

• Rebalance portfolio
• Update indicators (less frequently than OnTick)

OnChartEvent(): Handle user interactions

• UI elements
• Manual controls

Most EAs spend 95% of time in OnTick(). Optimize there first.

MQL5 Tips and Patterns

Tip 1: Always check returns

MQL5 functions return values indicating success or failure. Never ignore these. When you call OrderSend, capture the ticket number. If it returns negative, use GetLastError to diagnose the problem. A successful OrderSend returns a positive ticket number. Use this: int ticket = OrderSend(...); if (ticket > 0) { // Handle success } else { Print error message and handle failure }.

Tip 2: Use OnTimer() for resource-heavy operations

Don't calculate indicators every tick. Use OnTimer to calculate every 100ms or 1000ms. This reduces computational load significantly.

Tip 3: Implement proper slippage handling

Slippage is reality. Don't assume your entry happens exactly at your price. Get the current ask price from SymbolInfoDouble, then add your expected maximum slippage (typically 10 pips) to determine the maximum acceptable entry price.

Tip 4: Track execution results

Log every order attempt, success, and failure. Debug data is gold. Without logging, you can't diagnose why your EA behaved unexpectedly.

Tip 5: Implement circuit breakers

If something goes wrong (too many losses, unusual market conditions), stop trading. Check for losing streak thresholds (if more than 5 consecutive losses) and drawdown limits. When either is exceeded, set the EA to not trade.

Tip 6: Cache indicator values

Recalculating indicators every tick is expensive. Cache them and update periodically. Store the previous value and only recalculate when it's time.

Tip 7: Avoid magic numbers

Don't hard-code 14 (period) or 20 (pips) throughout your code. Use named constants. Define them at the top of your code: const int RSI_PERIOD = 14; const double MAX_SLIPPAGE = 0.0020;. This makes the code readable and modifiable.

Common MT5 Development Mistakes

I see these patterns repeatedly in poorly performing EAs:

Mistake 1: Not handling requotes and rejections

Your order gets rejected. You don't retry. Trade is missed.

Solution: Implement retry logic with exponential backoff.

Mistake 2: Float precision issues

Never use direct comparison for floating-point numbers in MQL5. Comparing if (price == 1.08500) will fail because of floating-point precision limitations. Instead, use epsilon comparison: check if the absolute difference between price and 1.08500 is less than _Point.

Mistake 3: Order management bugs

You open a trade, then immediately close it because your logic is wrong. Or you open multiple trades when you meant one.

Solution: Track position state carefully. Use OrderSelect() to verify before modifying.

Mistake 4: No database of trades

Without a trade database, you lose history when the EA restarts. Then your position tracking is wrong.

Solution: Log every trade to database immediately, not at end of day.

Mistake 5: Hardcoded symbol

Your EA works on EUR/USD. You drag it to GBP/USD. It fails because everything is hardcoded.

Solution: Use _Symbol throughout, never hardcode pair names.

Mistake 6: Not handling holidays/low-liquidity periods

You open a trade Friday before a 3-day weekend. Slippage is terrible. Losing trade is locked in.

Solution: Check volume and spread. Don't trade during low-liquidity periods.

Backtesting EA Performance

Getting the backtesting right is critical. Poor backtesting leads to false confidence.

How I set up backtesting:

1. Use tick data: Bar data is unrealistic. Use M1 (1-minute) data minimum.
2. Model slippage: Add 2-3 pips to every fill (realistic for major pairs).
3. Include commission: Add 2-4 pips per round-trip trade.
4. Run for multiple years: 3-5 years minimum to validate across different market conditions.
5. Validate walk-forward: Optimize on 2 years, test on 1 year (unseen data).

Backtest metrics I check:

• Win rate: 50%+ is acceptable (with proper position sizing)
• Profit factor: 1.5+ is solid
• Maximum drawdown: Under 20% is good
• Sharpe ratio: 1.0+ indicates good risk-adjusted returns

If your backtest shows 200% return with 5% drawdown, it's overfitted. It won't work in live trading.

Optimization Considerations

When optimizing EA parameters, I'm careful:

Optimization approach:

• Start with simple grid search to identify promising ranges
• Use genetic algorithm for fine-tuning (avoids local minima)
• Always validate on out-of-sample data
• Never optimize for profit; optimize for Sharpe ratio or profit factor

Parameter ranges: I typically test ranges, not individual values:

• RSI period: 10-20
• Stop loss: 50-100 pips
• Position size: 0.01-0.1 lot

Optimal parameters found: I always validate that optimal parameters make sense. If the optimal stop-loss is 200 pips, that's suspicious.

Live Trading Deployment

Moving an EA from backtesting to live trading requires caution.

Deployment steps:

1. Start with micro lots: Trade 0.01 lot size on real money
2. Monitor for 2 weeks: Does it perform as expected?
3. Gradually scale: Increase to 0.05 lots, then 0.1 lots
4. Continuous monitoring: Watch for unusual behavior

Live trading differences from backtest:

• Slippage is usually worse than modeled
• Spreads widen during low-liquidity periods
• Your broker might reject orders for various reasons
• Internet interruptions happen
• Market regimes change

If your EA performs 30% worse in live trading than backtest, that's typical. If it performs 70% worse, something is wrong (overfitting, unrealistic backtest assumptions).

Monitoring and Alerts

A running EA needs monitoring.

What I monitor:

• Is the EA still running? (disconnection can happen)
• Current drawdown (getting close to limit?)
• Win rate (has it degraded?)
• Recent trade profitability (is it still working?)

Alert triggers:

• EA hasn't traded in 24 hours (unusual)
• Drawdown exceeds 15% (warning)
• Drawdown exceeds 25% (stop trading)
• Error rate spikes (something is wrong)

Most MT5 hosting services provide basic monitoring. I set up additional monitoring because trading capital is at risk.

Version Control and Documentation

Treat your EA code like professional software:

Version control:

• Store code in git repository
• Track changes
• Have rollback capability

Documentation:

• Architecture overview
• Signal description
• Parameter meanings
• Known limitations
• Deployment instructions

When your EA has been running for 6 months and you need to modify it, documentation saves hours of relearning.

FAQ: Your MT5 Development Questions Answered

Q: Should I use an EA template or build from scratch?

A: Templates are useful for learning. For production, build from scratch using best practices. Templates often have bad habits you'll inherit.

Q: How do I handle EA updates without disrupting live trading?

A: Keep the EA running. Deploy new version to a test account first. Validate it. Then shut down old EA (let final orders close) and start new EA on live account.

Q: What's the best way to handle market gaps (holidays)?

A: Close all positions before market holidays. Reopening after gaps is risky due to slippage.

Q: How often should I optimize my EA's parameters?

A: Monthly reoptimization is typical. More often introduces overfitting. Less often and the EA becomes obsolete.

Q: Should I trade multiple symbols with one EA or use separate EAs?

A: Separate EAs per symbol is simpler and more reliable. Using one EA for multiple symbols introduces complexity.

Building for Reliability

Every decision in MT5 development should prioritize reliability over sophistication. An EA that trades consistently and survives drawdowns is better than an EA that looks brilliant but crashes under stress.

My philosophy: keep EAs simple, well-monitored, and defensive. Complexity is the enemy of reliability.

Debugging Common MT5 Issues

When EAs misbehave, knowing where to look is half the battle:

OrderSend returns negative number (failure): Check GetLastError(). Different error codes mean different problems. Document them.

EA doesn't execute trades: Check if terminal is in automated trading mode. Check if it has permission to trade. Check the journal.

Position closes unexpectedly: Check your stop-loss logic. Check if margin call happened. Check broker's position management rules.

Memory leaks: Check if you're creating objects without deleting them. Memory leaks degrade performance over time.

Indicator calculations are wrong: Check timeframe independence. Check if you're using wrong data series.

Systematic debugging beats random changes. Isolate the problem, make one change, test.

Advanced MT5 Techniques

For sophisticated EAs, additional techniques help:

Multi-timeframe analysis: Check 1-minute and 1-hour timeframes to confirm signals. More data = better decisions.

Ichimoku clouds: More sophisticated than moving averages for trend identification. Excellent in MT5 implementation.

Order management by time: Hold positions for fixed durations regardless of profit/loss. Useful for news trading.

Dynamic position sizing: Scale position size based on recent volatility. Higher volatility = smaller positions.

Correlation analysis: Check correlation with other pairs. Avoid correlated positions that magnify losses.

These advanced techniques require additional development time but improve EA sophistication significantly.

At Viprasol, every EA we deploy has survived this process: rigorous development, intensive backtesting, cautious live deployment, and continuous monitoring. That's what produces reliable trading systems.

For more on building robust trading systems, explore /services/trading-software/ and /services/quantitative-development/.