Introduction to Algorithmic Trading (EAs/Bots) & MQL4/5 Concepts 🤖

Algorithmic Trading = Pre-programmed computer instructions to automatically place trades based on your analytical and risk criteria.

Think of Expert Advisor as tireless assistant:

1. Monitors Markets 24/5

• Watches multiple pairs simultaneously
• Never sleeps, never breaks
• Catches setups at 3 AM
• Monitors every tick (milliseconds)

2. Analyzes Per Your Rules

• Checks H4 trend (HH + HL)
• Identifies MSS on M15
• Locates un-mitigated Order Blocks
• Measures Fair Value Gaps
• All based on YOUR defined criteria

3. Executes Without Emotion

• No fear after 3 losses
• No greed for quick profits
• No revenge trading
• No hesitation on valid setups
• Pure mechanical execution

4. Manages Risk Perfectly

• Calculates exact lot size for 1% risk
• Places SL at precise level
• Moves SL to BE at 1:1 R:R
• Scales out at targets
• Trails stops per rules
• Never violates risk rules

5. Runs Despite Your Absence

• Holiday? EA trading
• Sick? EA monitoring
• Asleep? EA executing
• 24/5 operation

The Truth:

• Manual = flexible but emotional
• Automated = rigid but flawless
• Best approach: Combine both

Understanding the difference between EAs and Indicators is fundamental to MetaTrader automation.

What Indicators Do:

• Display information on charts
• Calculate values (RSI, MA, custom metrics)
• Draw lines, boxes, arrows
• Cannot place trades
• Cannot manage risk

Examples:

• RSI showing 35 (oversold)
• Moving Average line on chart
• Custom Order Block highlighter
• Fair Value Gap box drawer
• Visual aids only

Use Cases:

• Mark Order Blocks automatically
• Highlight FVG zones
• Show MSS/BOS signals
• Calculate OTE zones
• Help YOU make decisions

What EAs Do:

• Execute trades automatically
• Place orders (market, limit, stop)
• Manage positions (modify SL/TP, close)
• Calculate lot sizes
• Monitor multiple pairs
• Run 24/5 without supervision

Examples:

• Order Block EA (enters at OB zones)
• Grid trading bot
• Scalping EA
• SMC automation system
• Full automation

Use Cases:

• Automate proven strategy
• Remove emotion from execution
• Trade while sleeping
• Monitor 10+ pairs simultaneously
• Let computer do the work

Common Setup:

Indicator (Visual Aid):

• Shows you where Order Blocks are
• Highlights Fair Value Gaps
• Marks MSS/BOS events
• YOU decide to trade

EA (Execution Engine):

• Monitors for OB + MSS + OTE conditions
• Automatically enters when ALL met
• Manages SL, BE, TP per rules
• EA decides AND executes

Hybrid Approach (Recommended for Beginners):

• Use indicators to identify setups
• EA only manages trade after YOU enter manually
• You control entries, EA controls risk management

MQL (MetaQuotes Language) is the programming language for creating EAs and indicators on MetaTrader.

MQL4:

• For MetaTrader 4 platform
• Simpler syntax
• Easier for beginners
• Large community, many resources
• Still widely used

MQL5:

• For MetaTrader 5 platform
• More powerful, object-oriented
• Faster execution
• Better for complex strategies
• Modern standard

Which to Learn:

• MT4 user → MQL4
• MT5 user → MQL5
• New to both → MQL5 (future-proof)
• Both similar enough to transfer knowledge

Key Functions Every EA Uses:

1. OnInit() — Runs once when EA starts

Use for: Setup, initialization, parameter validation
Example: Check if account has enough margin

2. OnTick() — Runs every price tick

Use for: Main strategy logic, check entry conditions
Example: "Is there MSS + OB + OTE? → Enter"
This runs thousands of times per day

3. OnDeinit() — Runs when EA stops

Use for: Cleanup, close positions if needed
Example: Close all trades when EA removed from chart

4. OrderSend() — Places new trade order

Use for: Executing buy/sell orders
Parameters: Symbol, Type, Lots, Price, Slippage, SL, TP
Example: Buy 0.5 lots EUR/USD at market

5. OrderModify() — Changes existing order

Use for: Moving SL to break-even, adjusting TP
Example: At 1:1 R:R, move SL to entry price

6. OrderClose() — Closes position

Use for: Taking profit, cutting loss, scaling out
Example: Close 50% at T1, let 50% run

Basic EA Logic:

void OnTick() {
  // 1. Check if we already have open position
  if (OrdersTotal() > 0) {
    ManageOpenTrades(); // Move SL, check TP
    return;
  }
  
  // 2. Check entry conditions
  bool trendBullish = CheckH4Trend();
  bool mssConfirmed = CheckM15MSS();
  bool atOrderBlock = CheckOBZone();
  
  // 3. If ALL conditions met
  if (trendBullish && mssConfirmed && atOrderBlock) {
    double lotSize = CalculatePositionSize(); // 1% risk
    double sl = CalculateStopLoss(); // Below OB
    double tp = CalculateTakeProfit(); // Liquidity pool
    
    OrderSend(Symbol(), OP_BUY, lotSize, Ask, 3, sl, tp);
  }
}

What This Does:

• Every tick: Checks if position open
• If yes: Manage it per rules
• If no: Check entry conditions
• If ALL met: Execute trade with calculated risk
• Fully automated Order Block trading

Automation is powerful but comes with both massive advantages and serious dangers.

1. Perfect Discipline

• Human: Skip valid setup due to fear after 3 losses
• EA: Takes setup #4 mechanically
• Result: Full expectancy realized

2. No Emotional Trading

• Human: Revenge trade after bad loss
• EA: Continues following rules regardless
• Result: No emotional mistakes

3. 24/5 Market Coverage

• Human: Sleep 8 hours, miss Asian session
• EA: Monitors all sessions, catches 3 AM setup
• Result: More opportunities captured

4. Multi-Pair Monitoring

• Human: Focus on 1-2 pairs realistically
• EA: Monitor 10+ pairs simultaneously
• Result: Diversification without overload

5. Flawless Risk Management

• Human: Calculate 0.47 lots, enter 0.50 by mistake
• EA: Calculates 0.4738, enters exactly that
• Result: Perfect 1% risk every trade

6. Backtesting Validation

• Human: Can't perfectly replicate historical trades
• EA: Same code for backtest and live = perfect match
• Result: Live mirrors backtest

1. Garbage In, Garbage Out

• Bad strategy automated = faster losses
• EA can't fix poor logic
• Automation amplifies your edge (positive OR negative)

2. Technical Failures

• Internet disconnection during trade
• Platform crash mid-execution
• VPS server downtime
• Result: Unmanaged positions, potential disaster

3. Coding Errors

• Bug in lot size calculation (risk 10% instead of 1%)
• SL placed wrong side of market
• Infinite loop opening trades
• Result: Account blown in minutes

4. Over-Optimization

• Tweak EA to perfection on historical data
• Overfit to noise
• Live performance collapses

5. Black Swan Events

• Algorithm can't handle unprecedented events
• Swiss Franc depeg (2015): many EAs destroyed
• Flash crashes trigger all stops
• Need manual override capability

6. False Confidence

• "It's automated, can't fail!"
• Stop monitoring
• Miss warning signs
• Result: Undetected problems compound

Mandatory Safeguards:

1. Maximum Daily Loss Limit (Coded):

if (dailyLoss >= accountEquity * 0.03) {
  CloseAllPositions();
  StopTrading = true;
  SendAlertEmail();
}

2. Maximum Drawdown Limit:

• Code hard stop at -12% from peak
• EA shuts down completely
• Requires manual restart after review

3. Max Open Positions:

• Never more than 3-4 positions
• Prevents runaway exposure
• Coded limit

4. Daily Monitoring (You):

• Check EA performance every 24 hours
• Review all trades taken
• Verify risk calculations correct
• EA is tool, YOU are manager

5. VPS Monitoring:

• Uptime alerts
• Connection health checks
• Automatic failover
• Infrastructure reliability

6. Kill Switch:

• Ability to instantly disable EA
• Close all positions remotely
• Emergency stop capability

Phase 1: Foundation (Months 1-6)

• Master manual trading first
• Prove strategy profitable (200+ trades)
• Document every rule objectively
• No coding yet

Phase 2: Learning MQL (Months 7-9)

• Learn MQL4/MQL5 basics
• Code simple indicator (OB highlighter)
• Study existing EA code
• Build programming foundation

Phase 3: Semi-Automation (Months 10-12)

• Code EA that manages trades only
• YOU enter manually
• EA manages SL, BE, TP, scaling
• Hybrid approach

Phase 4: Full Automation (Month 13+)

• Code complete EA with entry logic
• Extensive backtesting (500+ trades)
• 3-month forward test on demo
• VPS setup and monitoring
• Full automation with oversight

Learning Resources:

• MQL4/5 Official Documentation (mql4.com, mql5.com)
• MQL4 Tutorial for Beginners (free course)
• YouTube: "The MQL5 Guy," "Kirill Eremenko"
• Forums: MQL5 Community

Development Tools:

• MetaEditor (built into MT4/MT5) — Free IDE
• Visual Studio Code (with MQL extensions)
• Strategy Tester (for EA testing)

Hiring Option:

• Freelancer.com, MQL5 Freelance
• Hire coder to build EA from your rules
• Cost: $200-2000 depending on complexity
• Faster but requires clear documentation

To Build EA Yourself:

• Time: 100-300 hours learning + building
• Cost: $0 (free tools)
• Benefit: Full control, can modify anytime

To Hire Coder:

• Time: 20-40 hours (writing specifications)
• Cost: $500-2000
• Benefit: Professional code, faster deployment

Ongoing Costs:

• VPS: $20-50/month
• MT4/MT5: Free
• Monitoring time: 30 min/day
• Total: $240-600/year

ROI:

• If EA executes strategy with 0.3R expectancy
• 20 trades/month = 6R/month
• On $10K account, 1% risk = $100/trade
• 6R = $600/month additional profit
• VPS pays for itself in first month

Summary & Conclusion

Algorithmic trading transforms proven strategies into 24/5 execution machines.

Call to Action

🤖 Automation is the future, but mastery is the present.

Don't rush to automate. First, prove you can trade profitably manually. Then, automate to scale your proven edge.

Your Action Steps:

1. Master manual trading first (200+ profitable trades)
2. Document strategy with 100% objective rules
3. Learn MQL basics (if coding yourself)
4. Start with simple indicator (OB highlighter)
5. Progress to semi-automation (manual entry, EA manages)
6. Only then full automation (after extensive testing)

Automation amplifies your edge. Make sure your edge is positive first.

Remember: A profitable manual trader who automates becomes more profitable. An unprofitable manual trader who automates loses money faster. Prove it manually first.

Master the strategy. Then automate the execution.