NinjaTrader Strategy Analyzer: Futures Backtest Checklist

Direct answer

To run a reproducible futures backtest in NinjaTrader 8 Strategy Analyzer, record more than the strategy name and final net profit. Freeze the strategy version and parameters, identify the exact futures instrument and data series, set the date range and trading-hours template, configure commission, slippage and historical fill processing, then inspect individual Orders, Executions and Trades before relying on the Summary report.

The most important NinjaTrader-specific issue is the historical fill model. A Strategy Analyzer result is generated from historical data and platform rules; it is not a reconstruction of the live order queue. Standard and High Order Fill Resolution can produce different fills, and real-time or live results can still differ from either one.

Scope: This guide is about configuring and auditing NinjaTrader Strategy Analyzer. For the strategy specification written before testing, use the Backtesting Test Plan. For the row-by-row research record, use the Backtesting Spreadsheet and Execution Log.

Educational disclaimer: Historical and simulated results do not guarantee future performance. Futures trading can produce substantial losses. This article is a platform workflow, not a recommendation to trade a strategy or fund an account.

Open NinjaTrader if you need the desktop platform. This is a referral link; verify current platform, market-data and account terms directly before using it.

What NinjaTrader Strategy Analyzer actually tests

NinjaTrader describes Strategy Analyzer as the workspace for historical analysis of NinjaScript-based automated strategies. A basic backtest requires access to historical data and a NinjaScript strategy. The platform also includes sample strategies that can be used to learn the interface.

This distinction matters. Strategy Analyzer is not a generic chart-scrolling tool and it does not convert an informal idea such as “buy strong support” into a test automatically. The decision rules must already exist in a strategy that NinjaTrader can execute.

The main test types available in the settings panel include:

Backtest: run one strategy and parameter set over a historical period;
Optimization: run a range of parameter combinations against an optimization objective;
Walk Forward Optimization: optimize on one segment and test the selected parameters on a later segment;
Multi-Objective Optimization: compare parameter sets across more than one objective.

Start with a plain Backtest. Optimization should not be the first response to a weak or unexplained result. A baseline run is needed so you can verify that the strategy entered, exited and sized positions as intended.

Before opening Strategy Analyzer

Prepare a test specification first. At minimum, freeze:

Item	What to write down
Strategy identity	Strategy name, code version or build identifier
Hypothesis	The market behavior the strategy is intended to capture
Parameters	The exact values used in the baseline run
Instrument scope	Contract or instrument list being tested
Data scope	Bar type, bar value, price basis and historical period
Session scope	Trading-hours template and end-of-day behavior
Cost assumptions	Commission configuration and slippage in ticks
Fill assumptions	Standard or High Order Fill Resolution and limit-touch behavior
Decision rule	What result would lead to keep, revise or reject

This prevents a common research error: changing parameters, data, sessions and fill assumptions at the same time, then attributing the result change to the strategy.

Open Strategy Analyzer and create the baseline run

From NinjaTrader Control Center, open:

New > Strategy Analyzer

Select Backtest as the backtest type. Then configure the settings in a fixed order.

1. Select the strategy and freeze its parameters

Choose the NinjaScript strategy you intend to test. Strategy inputs appear dynamically in the Parameters section.

Before selecting Run:

capture the strategy version;
export or copy the parameter values;
confirm that the strategy compiled without errors;
confirm that its order quantity is controlled by the intended source;
do not optimize parameters during the baseline run.

If the strategy needs historical Trade objects inside its code, review IncludeTradeHistoryInBacktest. NinjaTrader notes that retaining those objects increases memory use, while disabling them can prevent code that depends on objects such as SystemPerformance.AllTrades from accessing completed historical trades.

This is a code-level setting, not a substitute for saving the visible Strategy Analyzer result.

2. Select the futures instrument carefully

The Instrument field can contain a single instrument or an instrument list. Record the exact selection rather than writing only “ES” or “NQ” in your notes.

For a futures test, the instrument choice can change:

the available historical data;
the tested date range;
trading hours;
point value and tick size;
commission assumptions;
rollover or contract-specific behavior.

Do not combine several contracts or instruments until a single-instrument baseline has been checked. Basket testing is useful later, but a combined result can hide an error that occurs on only one contract.

3. Define the Data Series

Record all three Data Series fields:

Price based on;
Type;
Value.

A strategy tested on one-minute bars is not the same test as the same strategy on five-minute bars. A change in bar type can also change signal timing and historical fill behavior.

NinjaTrader explicitly warns that discrepancies can be more visible with bar types such as Renko and Point & Figure. Those bars can be constructed differently in historical and real-time processing, so a visually attractive backtest on a synthetic bar type requires additional scrutiny.

4. Set the date range and trading-hours template

The Start date and End date define the historical window. The Trading hours template defines which sessions belong to the Data Series. Break at EOD controls whether bars are reset at the end of the trading day.

Record these together. A result can change because:

overnight data was included or excluded;
a session template changed;
an open position was carried across a session boundary;
the strategy exited at session close;
bars were formed differently around the end of day.

Do not describe the test merely as “two years of ES data.” The session definition is part of the experiment.

Configure costs and historical fill processing

This is the section most likely to turn a plausible futures backtest into a misleading one.

Include commission

Strategy Analyzer can include commission in performance results when a commission configuration is available. Record:

whether Include commission was enabled;
which commission template or account configuration applied;
whether the reported result is before or after those costs.

Avoid inserting a generic dollar amount into every futures test. Costs differ by contract, account arrangement and order volume, and they can change over time.

Slippage

The Strategy Analyzer Backtest settings include a Slippage value in ticks for supported market, stop-market and market-if-touched historical executions. NinjaTrader notes that the Summary can display the slippage in points.

Record the input in ticks and verify how it appears in the output. A value of zero is an assumption, not a neutral fact.

Standard Order Fill Resolution

Standard resolution uses the existing bar type and interval being tested. It is faster and may be appropriate for an initial baseline, but its fill logic relies on the information available from the historical bar series.

Use it to answer:

does the strategy run without errors?
do entries and exits occur in the expected general locations?
are the order types and quantities correct?
does the strategy produce a plausible trade sequence?

Do not use a profitable Standard-resolution summary alone as proof that intrabar orders would have filled at the same prices in real time.

High Order Fill Resolution

High resolution allows a more granular secondary bar series to be used for historical fill processing. It can reduce some ambiguity when the primary bar is too coarse for the order logic.

After the baseline run, repeat the test with High resolution when fill timing materially affects the strategy. Compare:

trade count;
entry and exit timestamps;
stop and target fills;
gross and net results;
drawdown path;
trades that appear in one run but not the other.

If the result changes materially, the finding is not simply “High is better.” It means the strategy is sensitive to fill assumptions and needs additional testing.

Fill limit orders on touch

This setting controls whether a limit order can be filled when price touches the limit. Record its state. A touch-based assumption can alter entry count and exit behavior for strategies that depend heavily on limit orders.

What historical fill processing cannot reproduce

NinjaTrader documents that historical fills and real-time fills use different information. Historical testing works from completed historical data and an algorithm. Real-time simulation can react to incoming price and volume, while live brokerage fills depend on actual market conditions.

Neither Standard nor High resolution guarantees reproduction of:

queue position;
every tick in the original market;
partial fills exactly as they occurred;
platform and network latency;
exchange matching behavior;
strategy market impact;
a live broker fill.

The old version of this article claimed that NinjaTrader backtests inherently used real bid/ask spreads. That claim has been removed. The safe interpretation is that historical fills depend on the selected data and configured historical fill model.

Check order-handling settings before Run

Do not skip the remaining fields simply because the strategy code looks correct.

Review:

Entries per direction;
Entry handling;
Exit on session close;
Set order quantity;
Time in force.

These settings can change the sequence without changing the entry signal itself. For example, a strategy may generate multiple entry signals but accept only one because Entries per direction or Entry handling prevents the others.

Write the values into the test record before running the backtest.

Run the test, then audit the sequence before the summary

Select Run. When the test completes, do not begin with the best-looking metric.

Strategy Analyzer provides multiple result views, including:

Summary;
Analysis;
Chart;
Executions;
Trades;
Orders.

Use them in this order:

1. Orders

Confirm that the strategy submitted the expected order type, quantity and timing. Look for duplicate, missing or unexpectedly cancelled orders.

2. Executions

Confirm how submitted orders were filled under the chosen historical model. Investigate fills that appear impossible relative to the displayed bar.

3. Trades

Confirm that entries and exits were paired as intended. Check whether session-close behavior, reversals or partial exits changed the apparent trade count.

4. Chart

Inspect representative trades visually. Check both winners and losers. A summary can look plausible while individual trades reveal a rule or timestamp error.

5. Summary and Analysis

Only after the event sequence passes inspection should you review aggregate performance. Use the metrics defined in the test plan; do not import generic pass thresholds from another strategy.

A positive total net profit does not by itself establish a stable strategy. A high trade count does not repair incorrect fills. A favorable Profit Factor does not prove the parameter choice was not selected after seeing the same data.

Save a reproducible Strategy Analyzer record

NinjaTrader Strategy Analyzer saves logs for backtests. The logs can include:

instrument;
backtest type;
test date;
strategy;
data series;
start and end dates;
parameters;
total net profit;
user notes;
pinned status.

Logs can be reopened to restore a prior configuration. For open, unlocked NinjaScript strategies, NinjaTrader also documents code-snapshot functionality in the log workflow.

Use the Notes field to add information that is not obvious from the visible result:

Purpose:
Strategy version:
Data source checked:
Contract or instrument list:
Trading-hours template:
Commission setting:
Slippage ticks:
Fill resolution:
Fill limit orders on touch:
Expected behavior:
Unexpected behavior:
Next test:

For a separate row-by-row research dataset, download or copy the fields from the Backtesting Spreadsheet and Execution Log.

A practical validation sequence for NinjaTrader futures tests

Use this order to isolate platform and strategy issues:

Baseline Backtest: one strategy version, one instrument, frozen parameters and Standard fill resolution.
Event audit: inspect Orders, Executions, Trades and representative chart examples.
Cost run: verify commission and slippage assumptions.
Fill-sensitivity run: repeat with High resolution when intrabar fills matter.
Session-sensitivity run: verify the intended trading-hours template and session-close behavior.
Instrument run: test another relevant futures contract only after the baseline is understood.
Holdout run: test data not used to develop the rules or parameters.
Walk-forward work: use Walk Forward Optimization only after the baseline strategy and parameter ranges are justified.
Real-time comparison: compare against simulation or Playback while expecting differences from the historical model.

This sequence is slower than pressing Optimize immediately, but it leaves a clearer evidence trail.

Optimization and walk-forward boundaries

NinjaTrader Optimization iterates over parameter ranges and ranks combinations using an optimization fitness measure. Large parameter sets can create many permutations and increase CPU use.

Optimization answers:

Which tested parameter combinations scored best on this historical optimization period under these settings?

It does not answer:

Which parameter set will be best in the future?

Walk Forward Optimization separates an optimization segment from a later test segment and repeats the process through time. This is more informative than evaluating optimized parameters only on the data used to select them, but it still depends on the chosen windows, parameter ranges, data and fill assumptions.

Keep the initial parameter ranges, optimization objective and walk-forward periods in the test plan before running them.

Why real-time and backtest results differ

NinjaTrader states that differences between real-time and historical results should be expected.

Typical causes include:

historical bars and real-time bars being built from different data events;
a single tick difference changing an indicator or signal;
historical fill logic using OHLC information rather than the live order queue;
data-provider differences;
timing differences between signal calculation and order submission;
Renko, Point & Figure, Heiken Ashi or other non-standard price construction;
slippage, latency and liquidity not matching the historical assumptions.

Treat a discrepancy as a diagnostic clue. Compare the first trade where the two runs diverge, then identify whether the difference began with data, signal timing, order submission or fill processing.

Strategy Analyzer vs NinjaTrader Playback vs ChartMini

Tool	Main use	What it does not establish
NinjaTrader Strategy Analyzer	Automated NinjaScript strategy testing on historical data	Live fill certainty or future profitability
NinjaTrader Playback / Market Replay	Replaying historical market events through a platform workflow	Identical live liquidity, latency or emotional pressure
ChartMini	Lightweight manual chart-reading and directional-decision practice	Automated NinjaScript results, broker execution or NinjaTrader result import

ChartMini does not import NinjaTrader backtest files, monitor live NinjaTrader performance or alert on strategy decay. The previous article incorrectly claimed those integrations and the claims have been removed.

For NinjaTrader Playback setup rather than Strategy Analyzer, use the separate NinjaTrader Replay setup guide.

Common configuration mistakes

Running Optimization before verifying one baseline trade sequence;
changing strategy code without changing the version label;
recording only the root symbol rather than the tested contract or instrument list;
omitting the trading-hours template from the test notes;
leaving commission or slippage assumptions undocumented;
treating Standard and High resolution as interchangeable;
enabling Fill limit orders on touch without recording it;
reviewing only the Summary instead of Orders and Executions;
assuming a historical fill represents queue priority;
using a favorable historical metric as a live-readiness threshold;
comparing two runs that used different data, sessions and parameters simultaneously.

Frequently asked questions

How do I run a backtest in NinjaTrader Strategy Analyzer?

Open New > Strategy Analyzer, choose Backtest, select a NinjaScript strategy, set the instrument, data series, date range, trading-hours template, costs and historical fill settings, then select Run. Save the exact settings and review the Orders, Executions and Trades displays before interpreting summary metrics.

Does a NinjaTrader backtest use real bid and ask order-book data?

Do not assume that it does. NinjaTrader historical fills are simulated from the selected historical series and fill-processing rules. Standard Order Fill Resolution uses the tested bar series, while High Order Fill Resolution can use a more granular secondary series. Neither setting reproduces the full live order queue, latency or market impact.

What is the difference between Standard and High Order Fill Resolution?

Standard resolution uses the existing bar type and interval being backtested and is faster. High resolution uses a secondary, more granular price series for historical fill processing. High resolution can reduce some bar-level ambiguity, but it still does not make a historical backtest identical to real-time execution.

Should commissions and slippage be included in a NinjaTrader futures backtest?

Record and test them whenever the goal is to evaluate results after trading costs. Strategy Analyzer can include configured commissions and apply slippage in ticks to supported historical order executions. The assumptions should match the contract, order type and test purpose rather than using one universal value.

Why can NinjaTrader real-time results differ from a backtest?

Historical tests use completed historical bars and a historical fill algorithm, while real-time simulation and live trading react to incoming market data and actual market conditions. Differences in bar construction, data feeds, order timing, liquidity and fill behavior can therefore change trades and results.

What should I save after each NinjaTrader backtest?

Save the strategy version, parameter set, instrument, contract, data series, date range, trading-hours template, commission and slippage assumptions, fill resolution, order-handling settings, result log and a short note explaining the test purpose. NinjaTrader Strategy Analyzer logs can preserve settings and, for open unlocked strategies, a code snapshot.

Official NinjaTrader references

Affiliate disclosure: ChartMini may receive a referral commission if you choose to open NinjaTrader through a ChartMini referral link. This does not affect the educational analysis or the platform limitations described above.