MQL4 / MQL5

MetaTrader (MQL4 / MQL5) Development

Custom MQL4/MQL5 programming for MetaTrader — Expert Advisors (EAs), indicators, optimization, backtesting, and live-deployment support. We deliver production-ready MQL code with clear documentation.

MetaTrader 5MetaTrader 4

What we do

The most common MetaTrader projects clients bring us — from one-hour fixes to complete systems.

EA design & implementation

MQL4/MQL5 Expert Advisors for automated entries/exits, money management and position sizing.

Modular development

Reusable components that speed testing, reduce bugs and simplify updates, integrating cleanly with MetaTrader.

Indicator development

Custom indicators, multi-timeframe logic and on-chart tools.

Backtesting & optimization

Rigorous historical testing with parameter sweeps and robustness checks, using platform-specific tools including MQL5’s walk-forward and multi-instrument features where applicable.

Broker & execution readiness

Simulated and live testing, order-type checks, fills and slippage handling.

Code review & performance tuning

Fix repainting, optimize loops and reduce CPU usage for MT4/MT5.

AI-generated code hardening

Review and harden AI-written MQL4/MQL5: fix order and error handling, remove look-ahead bias, add risk controls, and deliver tested, deployable code.

Ongoing support & maintenance

Hourly support or retainer plans for updates, bug fixes and adapting strategies as market structure changes.

NDAs available on request.

What MQL5 looks like

A simple demonstration of a moving-average crossover. Production projects add documentation, input validation and a change log.

MACrossAlert.mq5 — MQL5
input int FastPeriod = 10;   // Fast MA period
input int SlowPeriod = 50;   // Slow MA period

int      fastHandle, slowHandle;
datetime lastAlertBar = 0;

int OnInit()
{
   fastHandle = iMA(_Symbol, _Period, FastPeriod, 0, MODE_SMA, PRICE_CLOSE);
   slowHandle = iMA(_Symbol, _Period, SlowPeriod, 0, MODE_SMA, PRICE_CLOSE);
   return(INIT_SUCCEEDED);
}

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   if(rates_total < MathMax(FastPeriod, SlowPeriod) + 3)
      return(rates_total);

   double fast[2], slow[2];
   if(CopyBuffer(fastHandle, 0, 1, 2, fast) < 2) return(prev_calculated);
   if(CopyBuffer(slowHandle, 0, 1, 2, slow) < 2) return(prev_calculated);

   if(fast[0] <= slow[0] && fast[1] > slow[1])
   {
      datetime signalBar = time[rates_total - 1];
      if(signalBar != lastAlertBar)
      {
         lastAlertBar = signalBar;
         Alert(StringFormat("%s %s: MA(%d) crossed above MA(%d)",
                            _Symbol, EnumToString(_Period),
                            FastPeriod, SlowPeriod));
      }
   }

   return(rates_total);
}

Why our MetaTrader work stands out

  • MQL4/MQL5 developers with hands-on trading experience.
  • Production reliability focus — defensive coding, robust error handling and clear versioning.
  • Configurable risk controls — position sizing, stop logic and real-world order management available on request.
  • Trader-focused deliverables — readable source code, clear setup guides and reproducible backtest reports.

Typical engagement

  1. Intake & objectives

    We hold an intake meeting to define instruments, timeframe and risk limits, and review any sample data or scripts you provide.

  2. Functional spec & estimate

    You receive a written scope with deliverables, milestones and an estimated range of hours, plus checkpoints and transparent time tracking.

  3. Development & review

    We implement the agreed specification in MQL4 / MQL5 and walk you through the results for approval.

  4. Validation (optional; recommended for strategies)

    We run in-sample / out-of-sample backtests, walk-forward tests and sensitivity analysis.

  5. Handover

    You receive the final MQL4 / MQL5 source code, documentation and test results.

  6. Deployment support (optional)

    We assist with broker checks, paper-trading runs and go-live readiness, with the option of ongoing support.

Projects are billed hourly; estimates follow scoping. We notify you upfront if work is likely to exceed the initial estimate.

Deliverables you receive

  • MQL4/MQL5 source code with inline comments — stress-tested and validated in-house.
  • Deployment & user guide (PDF): input descriptions, setup instructions, MetaTrader version notes, and data-feed/broker settings.
  • Backtest report (optional): equity curve, drawdown, trade stats and a brief plain-English interpretation.
  • Walk-forward summaries where applicable.
  • Versioned release and change log.

Case studies

Anonymized examples of MetaTrader projects we have delivered.

Multi-symbol portfolio EA

Consistent portfolio risk across correlated instruments

CTA / hedge-fund desk Development effort ≈90 hours

Problem
Manual management of multiple correlated instruments produced inconsistent position sizing, occasional aggregate-risk breaches, and time-consuming spreadsheet workflows for rebalancing and attribution.
Solution
A portfolio EA that normalizes instrument volatility, applies target-risk allocation with dynamic weights, enforces net-exposure and margin caps, and supports execution batching with optional rebalancing. Includes a dashboard for portfolio P&L, per-symbol risk contribution and attribution, plus exportable execution records for audit and post-trade analysis.
Outcome
Replaced manual spreadsheet processes with automated allocation and controls: consistent position sizing across correlated instruments, clearer attribution, and an auditable execution record.
Deliverables
Portfolio EA, dashboard, risk configuration, backtest template, user guide.

Chart Trader interface with one-click order buttons

Faster, safer manual execution

Prop trading desk Development effort ≈70 hours

Problem
Manual order entry and trade management during high-volatility sessions were error-prone, slowed execution, and caused inconsistent risk application.
Solution
A floating chart-trader panel with configurable one-click entry buttons, preset size buckets, quick scale-in/out, and optional auto-sizing (risk % × stop distance). Adds automated position rules (breakeven, trailing, partial take), visual order-state badges, keyboard hotkeys, pre-trade safety checks (max exposure, spread/margin filters), and per-instrument overrides. Integrated trade logging with exportable reports.
Outcome
Chart-based one-click execution with configurable safety checks, automation, and exportable logs for review and compliance.
Deliverables
EA with chart panel and trade logger, hotkey mapping, safety-check module, user guide.

Multi-leg trading strategy

Automated multi-leg execution and risk control

Retail trader Development effort ≈20 hours

Problem
Multi-leg setups were slow to test and easy to mismanage in live execution.
Solution
An EA with dependency rules and exposure limits.
Outcome
Consistent live execution and reduced manual error.
Deliverables
Multi-leg EA with risk manager, user guide.
Dark MetaTrader chart with green OHLC bars where bold cyan lines connect several staggered long entries to a shared exit point, tracing the legs the EA executed, with a short leg drawn in red.

Multi-symbol correlation dashboard

Real-time hedging signals and diversification insight

Prop trader Development effort ≈35 hours

Problem
No compact correlation views for hedging or diversification.
Solution
Rolling-correlation modules with a heatmap, customizable instruments, lightweight aggregation, and CSV export.
Outcome
Improved identification of diversification, hedging, and trading opportunities.
Deliverables
Dashboard indicator, export utility, user guide.

Volatility-adaptive position-sizing module

Position sizes aligned to current market volatility

Independent trader Development effort ≈10 hours

Problem
Fixed lot sizing ignored volatility.
Solution
N-period rolling standard deviation of log returns, with configurable risk, an SD floor, and drawdown caps.
Outcome
Per-trade sizes adapt to current volatility instead of staying fixed.
Deliverables
Sizing module, integration examples, user guide.

Virtual Renko bar EA

Consistent Renko trading & backtesting

Retail trader Development effort ≈25 hours

Problem
MetaTrader lacks native Renko charts.
Solution
An EA that builds virtual Renko bricks from ticks and drives logic from brick events.
Outcome
Reliable Renko signals and reproducible backtests.
Deliverables
Virtual Renko EA, sample strategy, guide.

Pricing guide

Indicative ranges. Every project is quoted after scoping.

Indicators / custom studies

$500 – $1,200

Single EA (spec, backtest, deployment guide)

$1,200 – $4,000

Complex portfolio systems / custom Chart Trader

$4,000+ (custom quote)

Projects are billed hourly. A final quote follows scoping and review of any existing code. Retainer and ongoing-support options are available and priced in proposals.

Frequently asked questions

What are typical timelines?

Simple indicators — days; strategies — 1–3 weeks; complex systems — 4–10+ weeks.

Can you work with existing code?

Yes. We routinely take over, rescue and improve MQL projects: diagnose issues, fix bugs, refactor for clarity and speed, extend functionality, and deliver tested, deployable code.

Can you fix code I generated with ChatGPT, Claude or another AI?

Yes — and you’re in good company; it’s one of our most common requests. AI tools are a quick way to prototype an idea, but the generated MQL4/MQL5 code is often unsafe to trade as-is: typical issues include repainting, look-ahead bias that flatters backtests, fragile order handling and missing risk controls. We review the code against the rules you intended, fix what’s broken, harden it for live conditions and validate the result with proper testing. Send us the code and a short description of what it should do, and we’ll take it from there.

Which MetaTrader versions do you support?

Both MetaTrader 4 and MetaTrader 5. We develop for current desktop builds and note version-specific caveats in deliverables.

Do I receive the source code?

Yes. Every project is delivered as documented, readable source code — not a compiled black box — together with usage instructions.

Do you guarantee profits?

No. You get reproducible testing, documented assumptions and deployment best practices — but no performance guarantees.

Is an NDA available?

Yes — available on request. Independent of any NDA, nothing you share is disclosed to a third party without your prior written consent.

Technical notes & best practices

  • Every delivery includes a PDF manual covering inputs, settings, usage and deployment steps, alongside inline code comments and a change log.
  • Backtests include reproducible scripts and data-range notes for independent verification.
  • Strategy code is written to prevent repainting and look-ahead bias, handle bar replay correctly, and document intrabar execution caveats.
  • Order handling in live EAs is written for broker reality — requotes, slippage, partial fills and minimum stop distances are checked rather than assumed away.
  • Nothing broker-specific is hard-coded — symbol properties, digits, lot steps and margin rules are read from the terminal at runtime.
  • Strategy-tester results are cross-checked in visual mode, and MQL5 walk-forward and multi-instrument features are used where they add value.

Ready to turn your idea into working MetaTrader code?

Book a free 15-minute consultation to discuss scope, timeline and pricing. We respond within one business day — often the same day.