MT4 Strategy Tester Modeling Quality: What 90% Actually Means

It means your "Every tick" backtest was built entirely from ticks that MT4 simulated by interpolating inside 1-minute bars — and 90% is the maximum score the tester will ever assign to that method. It is a label for data granularity, not a measurement of accuracy: MetaQuotes deliberately capped M1-interpolated tests at 90% to signal that generated ticks are never equivalent to real ones. A report showing 90% therefore tells you two things — M1 history covered your whole test window (good), and every single tick your EA traded against was synthetic (the caveat).

The misunderstanding this article exists to correct is treating the number as a grade, as in "my backtest is 90% reliable." It is closer to a level indicator on a fixed ladder. "Open prices only" and "Control points" modes report "n/a"; "Every tick" reports a percentage that rises toward 90% as more of the test period is covered by genuine M1 data rather than coarser bars — and stops there, permanently, because standard MT4 has no access to real tick history at all. There is no configuration, broker, or download inside a stock MT4 terminal that produces a number above 90%.

When traders talk about "99% modeling quality," they mean something outside standard MT4: third-party tooling that injects genuine historical tick data (commonly Dukascopy's) into the tester, discussed in the final section. Between 90% and 99% lies the entire difference between an invented intrabar price path and a recorded one — which, for some strategy types, is the difference between a meaningful test and a meaningless one. The sections below unpack the formula behind the number and the interpolation algorithm behind the ticks.

MT4 computes modeling quality from where its ticks came from, using fixed weights that MetaQuotes documented for the tester. Conceptually, the test period is split into segments by the granularity of data available to generate ticks, and each segment is weighted:

• Segments where ticks had to be generated from bars of the chart's own timeframe (no finer data available) carry a weight of 0.25.
• Segments generated from the nearest lower timeframe carry a weight of 0.5.
• Segments generated from genuine M1 bars — the finest history MT4 stores — carry a weight of 0.9.

The reported percentage is the weighted proportion across the whole test window. The consequence is immediate: even when M1 data covers every minute of your test, the score is 0.9 × 100% = 90%. The cap is not a data-download problem to be fixed; it is the formula's ceiling, an engineering admission that interpolated ticks max out at "pretty good bar coverage," never "real."

Reading intermediate values becomes straightforward with the weights in mind. A quality of, say, 62% typically means a meaningful early chunk of your test period predates your M1 history and was modelled from coarser bars — MT4 brokers often provide only a year or two of M1 data by default, while higher-timeframe history reaches back much further. The practical hygiene: check the tester's journal for "TestGenerator: unmatched data error" messages, align your test window to your actual M1 coverage, and treat any run that mixes granularities as two tests of different quality stitched together. And a red flag worth knowing: a fixed 25% or a mismatch between chart history and M1 history often signals corrupted or misaligned history files, which no amount of interpolation can salvage.

In "Every tick" mode, MT4's test generator takes each M1 bar — four prices and a tick volume — and manufactures a tick sequence inside it. The algorithm is deterministic, not random: it routes price along predefined wave templates from open to close, visiting the high and low along the way, choosing the template by the bar's shape (which extreme sits closer to the open, roughly mirroring the same reasoning TradingView's emulator uses) and scaling the number of generated reference points with the bar's tick volume. Low-volume bars get sparse zigzags of a few ticks; high-volume bars get denser ones. "Control points" mode is cruder still — a fractal interpolation over roughly a dozen reference points from the nearest lower timeframe, suitable only for quick parameter sweeps — and "Open prices only" models nothing intrabar at all.

What the generated sequence structurally cannot contain is exactly what live trading is made of. Real tick order: within a real minute, price may cross a level five times; the synthetic zigzag crosses it in one clean pass, so an EA's stop or pending order triggers once, at an idealised moment. Spread dynamics: MT4's tester applies an essentially fixed spread (by default, the current spread at test start) across the entire test — news-time spread explosions, the very thing that kills tight-stop strategies live, simply do not occur. Sub-minute gaps and bursts: the interpolation is continuous by construction, so price never jumps over your stop level; every stop fills exactly at its price, which live execution does not guarantee.

Each of these simplifications biases results in the flattering direction. That is the honest way to read "Every tick, 90%": the best simulation stock MT4 can build, with known optimistic assumptions baked in — usable for logic validation, structurally unable to certify anything that depends on real intrabar behaviour.

The damage is not uniform. A strategy that trades on completed H4 bars with stops several hundred points wide barely notices synthetic ticks: its decisions and exits live at bar scale, where the data is real. The strategies that break are the ones whose outcomes are decided inside single M1 bars:

• Scalpers with targets and stops of a few points — most trades open and close within one or two M1 bars, meaning virtually every recorded outcome was determined by the wave template, not by market microstructure.
• Tight-bracket systems whose SL and TP both fit inside a typical M1 range — the interpolated path decides which side wins, the same-bar ambiguity problem in its sharpest form.
• News and breakout EAs — precisely when real spreads blow out and real ticks gap, the tester supplies smooth interpolation and a calm fixed spread.
• Pending-order grids with levels spaced inside M1 ranges — synthetic single-pass paths fill them in an idealised order.

A quick, concrete self-check: measure how often a single M1 bar spans your take-profit distance. If it is often, your backtest outcomes are largely interpolation artefacts.

4
// Educational only — validate before trading; not financial advice.
// How often does one M1 bar span your take-profit distance?
void OnStart()
  {
   double tpPoints = 100;      // your TP distance in points
   double tpPrice  = tpPoints * _Point;
   int    total    = 5000;     // M1 bars to sample
   int    spanned  = 0;
   for(int i = 1; i <= total; i++)
     {
      double range = iHigh(_Symbol, PERIOD_M1, i) - iLow(_Symbol, PERIOD_M1, i);
      if(range >= tpPrice)
         spanned++;
     }
   Print("M1 bars spanning TP distance: ", spanned, " of ", total,
         " (", DoubleToString(100.0 * spanned / total, 1), "%)");
  }

Run it as a script on your symbol. Single-digit percentages suggest bar-scale logic that the tester models tolerably; large percentages mean your edge lives below the resolution of the data — where MT4 is guessing.

If your strategy genuinely operates at sub-minute scale, the answer is not a better interpolation — it is replacing interpolation with recorded ticks. Two established routes exist.

Third-party tick data in MT4. Tools such as Tickstory and Birt's Tick Data Suite inject genuine historical tick data — most commonly Dukascopy's freely downloadable feed — into the MT4 tester, bypassing the generator entirely. These are the setups behind "99% modeling quality" claims: the figure signals real-tick testing rather than a score MT4 itself can produce, and the serious tools add variable historical spread and configurable slippage, addressing the fixed-spread flattery directly. The costs are real too: multi-gigabyte datasets, slow test runs, a data feed from one broker's pricing rather than yours, and a third-party layer between you and the tester that itself needs validating.

MetaTrader 5. MT5's Strategy Tester natively offers "Every tick based on real ticks," pulling your broker's actual recorded tick history where available. For new development at fine timescales, this is the structurally sounder platform — with the caveats that brokers' real-tick history is often shallow (frequently only a few years), gaps fall back to generated ticks silently, and the ticks are still your broker's record, not a universal truth.

And the limit that no data source removes: even a perfect tick-by-tick replay is a record of a market your orders were not part of. Live execution adds latency, requotes, slippage, and the impact of your own order — none of which any tester models. Rising modeling quality shrinks one specific class of error; it does not convert a backtest into a forecast. Use 90% as what it is — a granularity label with known optimistic assumptions — reserve fine-grained conclusions for real-tick tests, and hold even those loosely. This is educational material only, not financial advice, and trading carries a real risk of loss.