Last updated: September 2026

Can an automated futures trading strategy actually progress from simulation testing to a prop-firm evaluation, a funded trading account and eventually real payouts?

That's what I'm trying to find out.

I've spent a lot of time trading futures, testing different strategies and developing automated trading systems. Along the way, I've become increasingly interested in a simple idea: instead of trying to manually capture every small movement in the market, could I build a strategy that takes trades automatically, controls its risk and gives itself enough room to capture the occasional large move?

This page documents that experiment.

I'm starting with the Micro E-mini Nasdaq-100 futures contract (MNQ) and an automated strategy I've developed for NinjaTrader.

Rather than showing a backtest after I've already optimized everything and presenting the finished result, I want to document what happens as I actually test and develop the strategy.

That includes the good results.

It also includes losing periods, drawdowns, strategy changes, failed ideas and potentially failed prop-firm evaluations.

The initial simulated results have been encouraging, but this experiment is still at a very early stage.

My first published five-day test produced $2,019.50 in simulated net profit from 46 trades, using two MNQ contracts.

That does not mean I've discovered a money-making machine.

It means I've found something interesting enough to continue testing.

This page will be updated as the experiment develops.

Current Automated Trading Experiment

Here is where the experiment currently stands.

The strategy will continue changing as I collect more information.

Whenever I make a material change, I'll document it on this page rather than quietly replacing the old results.

What Is My Automated Futures Trading Strategy?

My automated futures trading strategy is a rules-based system designed to identify opportunities in the futures market, enter positions and manage those positions programmatically.

I'm currently developing and testing it primarily on MNQ futures.

I'm deliberately not publishing the exact entry algorithm or source code here. However, I want this experiment to be transparent enough that anyone following along understands the general methodology, risk and results.

The strategy isn't designed around predicting every small movement in Nasdaq.

In fact, my thinking has increasingly moved in the opposite direction.

The Basic Idea Behind My Strategy

One of the biggest lessons I've taken from developing trading systems is that markets are noisy.

Nasdaq can move rapidly in one direction, retrace and then continue.

A very small stop might reduce the dollar amount lost on an individual trade, but it also gives the market very little room to fluctuate before the trade is eliminated.

My current approach is therefore based around a different idea:

Give the initial trade enough room to develop, but become increasingly defensive once price moves significantly in my favour.

I'm not trying to make every trade a winner.

I'm interested in whether a series of controlled losses and smaller trades can be outweighed by larger winning trades when Nasdaq makes a substantial move.

That has also changed the way I think about profit targets.

Rather than deciding that every successful trade needs to make exactly 10, 20 or 30 points, I'm increasingly interested in allowing the market to determine how large a winning trade becomes.

What Market Does the Strategy Trade?

The current strategy trades Micro E-mini Nasdaq-100 futures (MNQ).

MNQ tracks the Nasdaq-100 and is the micro-sized version of the E-mini Nasdaq-100 futures contract (NQ).

The smaller contract size is particularly useful for this experiment because it allows me to reduce the dollar risk without fundamentally changing the strategy.

This becomes especially important when moving from simulated trading to a prop-firm evaluation.

Instead of trying to maximize the amount of money the strategy can theoretically make, I can run a single MNQ contract and concentrate on whether the underlying strategy can survive.

What Timeframe Does My Strategy Use?

My current strategy uses a 2-minute chart for its primary trading logic.

However, there's an important distinction between the chart timeframe and the way I manage an open position.

The strategy can generate its trading logic from the 2-minute chart while managing an active position using incoming tick data.

That has become one of the most important developments in the strategy so far.

I'll explain why shortly.

Does the Strategy Trade Long and Short?

Yes.

The current version is allowed to take both long and short trades.

During my first published test, there were:

26 long trades

and

20 short trades.

The long side generated $1,078.50, while the short side generated $941.00 in simulated net profit.

That's encouraging because the week's performance wasn't entirely dependent on one market direction.

However, 46 trades is nowhere near enough information to conclude that both sides have a durable edge.

That's something I'll monitor as the sample increases.

Why I Built an Automated Futures Trading Strategy

There are thousands of automated trading strategies available online, so why spend time developing another one?

For me, this project grew out of my experience with discretionary trading.

The Problem With Manual Execution

Manual trading introduces an enormous number of decisions.

Should I enter?

Should I wait?

Is this setup good enough?

Should I increase my position?

Should I take profit?

Should I move my stop?

Should I give the trade more room?

Should I re-enter?

And perhaps the most dangerous:

Am I about to miss the move?

Even when the underlying trading idea is reasonable, execution can change depending on what the trader is feeling at that particular moment.

Automation changes that.

The computer doesn't care that the previous trade lost.

It doesn't know that I missed a huge Nasdaq move yesterday.

It doesn't become excited because the account is having a good day.

It simply executes the instructions it's been given.

Of course, that doesn't mean automation eliminates human error.

I wrote the rules.

I can change them.

I can increase the size.

I can disable the strategy.

I can interfere with a position.

Automation moves the human decision-making to a different part of the process rather than magically eliminating it.

That's one reason I'm interested in seeing what happens when I reduce my involvement after the strategy starts running.

Why I Started Questioning Small Scalps

For a long time, I was interested in small stops and relatively small movements.

The attraction is obvious.

Risk a small amount, capture a small movement and repeat the process.

But the more I tested, the more I began questioning whether I was trying too hard to extract tiny movements from a market capable of enormous moves.

Nasdaq doesn't move neatly.

A trade can initially move against you, turn around, move substantially into profit, retrace and then continue again.

Trying to control that entire process with an extremely tight stop can result in being correct about the larger movement while repeatedly being stopped out by normal market noise.

That led me toward the approach I'm testing now.

My Current Hypothesis

The hypothesis is relatively simple:

Could I accept a wider initial stop, use small position sizing, react quickly once the market moves in my favour and leave enough upside available to capture unusually large movements?

I don't yet know whether that hypothesis will survive a large sample.

But it's testable.

And that's what this experiment is designed to determine.

How My Automated Futures Trading Strategy Works

I'm not going to publish the exact entry algorithm because this is still an actively developed proprietary strategy.

But the trade-management principles aren't a secret.

Automated Trade Entries

The strategy monitors the market for its programmed entry conditions.

When those conditions are satisfied, it can enter automatically.

That removes the need for me to sit at the computer waiting for the exact moment an entry condition occurs.

This is particularly useful because I'm currently interested in testing the strategy across almost the entire futures trading day.

My Initial Stop Loss

The current default initial stop is:

150 MNQ ticks.

MNQ has four ticks per Nasdaq point, so:

150 ticks = 37.5 Nasdaq points.

At one MNQ contract, that represents approximately:

37.5 points × $2 = $75

of initial market risk before commissions and slippage.

At two MNQ contracts, it becomes approximately $150.

This is a considerably wider stop than I'd use for a very short-term scalping strategy.

But the position size is deliberately kept small.

That's an important distinction.

A wider stop doesn't necessarily mean I have to accept enormous dollar risk. Contract size can be reduced to compensate.

Why I'm Using a Wider Initial Stop

The wider stop is there to give the trade room.

I don't want an ordinary fluctuation in Nasdaq to automatically remove the strategy from every potentially good position.

But I also don't necessarily want to continue risking the entire 150 ticks after the trade has moved significantly in my favour.

That's where the trailing system becomes important.

Why I Changed to Tick-Based Trailing

This has been one of the most interesting discoveries during development.

Originally, I experimented with trailing the stop based on completed candles.

That seems logical.

Wait for the bar to close, evaluate what happened and then adjust the stop.

But there's a major problem when trading a fast-moving market like Nasdaq.

What Happens Inside a Two-Minute Candle?

A two-minute candle only shows four basic pieces of information after it's completed:

Open.

High.

Low.

Close.

But an enormous amount can happen between the open and close.

Imagine my strategy enters a long position.

Price suddenly moves 40 points higher.

For a brief period, the trade has a substantial unrealized profit.

Then Nasdaq reverses.

By the time the two-minute candle closes, price might only be five points above the entry.

A strategy waiting for the candle close could effectively ignore most of that favourable excursion.

The market offered the trade a substantial profit.

But the trade-management logic never reacted to it.

Managing the Position on Every Tick

My newer approach is different.

Once a position is open, the strategy can monitor incoming tick data and determine whether its trailing conditions have been satisfied.

That means it doesn't necessarily need to wait for the two-minute candle to finish.

If the market makes a fast favourable movement, the strategy can potentially react while that movement is occurring.

This is one area where automation has a practical advantage over manual trade management.

A human trader has to observe the movement, interpret what's happening, grab the mouse and change an order.

A program can evaluate its rules as market data arrives.

That doesn't guarantee a good fill, and real-world execution introduces latency and slippage.

But it allows me to design the strategy around movements that occur inside the candle, rather than only evaluating the final candle close.

Why This Could Matter to the Results

Consider a trade that reaches a significant unrealized profit and then reverses into the original stop.

Under one management system, that trade might become a full loss.

Under another, the favourable excursion could activate the trailing logic and reduce the loss, create a scratch trade or potentially lock in a profit.

Across one trade, that difference might not matter much.

Across hundreds of trades, it could completely change the distribution of returns.

That's something I'll be paying particularly close attention to as this experiment continues.

Why I Don't Want a Small Fixed Profit Target

This follows directly from the philosophy behind the strategy.

If I accept a relatively wide initial stop because I want to give trades room to develop, it doesn't make much sense to automatically eliminate every successful trade after a tiny profit.

Nasdaq occasionally makes enormous moves.

I don't know which entry will precede one of those moves.

That's the point.

If I knew beforehand, trading would be very easy.

Instead, I want the trade-management system to give successful positions the opportunity to become unusually large winners.

There will be a trade-off.

Some positions will move significantly into profit and then give part of that profit back before the trailing stop is hit.

That's unavoidable with this type of approach.

The question isn't whether I can capture every point.

The question is whether allowing those larger extensions produces a better overall outcome across a sufficiently large sample.

Why I'm Testing Almost 24-Hour Automated Trading

During the initial experiment, I allowed the strategy to operate for approximately 23 hours per day.

That was deliberate.

I could have run hundreds of historical tests and selected only the hours that happened to make the most money.

That would undoubtedly make the results look better.

But it introduces another problem.

The Danger of Optimizing Trading Hours

Suppose five trades occurred at 7:00 am this week and all five won.

Does that prove 7:00 am is the ideal time to trade?

Of course not.

It's five trades.

But if I optimize the strategy based on those results, I could easily convince myself that I've discovered something meaningful when I've simply fitted the strategy to a tiny historical sample.

For the initial test, I'd rather collect information.

Let the strategy trade.

See what happens.

Then, once I have hundreds or potentially thousands of trades, I can investigate whether there are genuine differences between trading periods.

What Did the First Week Show?

There were already significant differences.

Some hours were strongly profitable.

Others lost money.

For example, the initial test showed profitable results during several overnight and morning periods, while other periods around the late morning generated losses.

That's interesting.

But it's not enough information for me to start switching hours off.

For now, I'm collecting data rather than trying to make the historical results perfect.

Automated Futures Trading Strategy Results

This section will be continuously updated.

My intention is to keep the major statistics here while publishing separate articles for individual weeks and important milestones.

First SIM Test: September 14–18, 2026

My first published test ran from September 14 through September 18, 2026.

The strategy traded MNQ using two micro contracts on a simulated account.

It operated approximately 23 hours per day and was allowed to trade both long and short.

Here were the results:

Those are encouraging numbers.

But they're also only 46 trades.

I don't consider that sufficient evidence to conclude that the strategy has a durable edge.

Daily Results

The simulated daily results were:

Every day happened to finish positive.

Again, I don't expect that to continue indefinitely.

In fact, I want this experiment to eventually contain losing days and losing weeks because I need to know what the strategy looks like when conditions aren't favourable.

The largest daily drawdown during this initial sample was approximately $301.

That's an important number when thinking about the next stage.

Why I'm Reducing the Strategy to One MNQ

It might seem strange to produce a profitable test with two contracts and then reduce the size.

But I'm not trying to maximize the simulated profit.

I'm trying to determine whether the strategy survives.

At one MNQ, the current 150-tick initial stop represents approximately $75 of initial market risk.

That gives me considerably more breathing room inside a prop-firm evaluation.

It also reduces the temptation to focus on the dollar amount generated by each individual trade.

If the strategy genuinely has an edge, it shouldn't require me to take excessive risk to demonstrate it.

First prove the process.

Scaling can come later.

The $25,000 Prop-Firm Evaluation Experiment

The next major stage is to move beyond SIM.

My current plan is to run the strategy on a $25,000 prop-firm evaluation account using one MNQ contract.

This is where the experiment becomes considerably more meaningful.

Why Use a Prop-Firm Evaluation?

A simulated account is useful for developing and observing a strategy.

But there's no financial consequence if it fails.

A prop-firm evaluation introduces constraints.

There is typically a profit objective.

There is a drawdown limit.

There may be daily loss restrictions.

And ultimately, the strategy either satisfies the requirements or it doesn't.

That gives me a clear next test.

Stage 1 — Simulation

Can the strategy produce interesting enough results to justify further testing?

Initial answer: yes.

Stage 2 — Evaluation

Can it reach the required target without violating the account's risk rules?

That's next.

Stage 3 — Funded Trading

If it passes, can it survive after the evaluation?

Stage 4 — Payout

Can it actually produce money that can be withdrawn?

Stage 5 — Repeatability

Can the process be repeated?

That final stage is ultimately the one that matters most.

Passing one evaluation doesn't prove very much.

Neither does receiving one payout.

What interests me is whether a controlled process can be repeated over a meaningful period without eventually giving everything back.

Backtesting vs SIM vs Evaluation vs Funded Trading

These terms are often mixed together online, but they're very different.

What Is a Backtest?

A backtest applies strategy rules to historical market data.

It asks:

What would have happened if these rules had been applied to this historical period?

Backtesting is extremely useful.

It's also extremely easy to abuse.

If I repeatedly change settings until the historical results look perfect, I may simply be fitting the strategy to past market behaviour.

That doesn't guarantee those conditions will repeat.

What Is SIM Trading?

SIM, or simulated trading, applies the strategy without risking real capital.

Depending on the setup, it can allow the strategy to interact with current market data while orders are simulated rather than actually executed in the market.

That's the stage represented by my first published results.

What Is a Prop-Firm Evaluation?

A prop-firm evaluation introduces a set of rules the trader must satisfy before progressing to the firm's funded stage.

Rules vary between firms and account types.

For my experiment, the important thing isn't simply passing.

I want to know whether the strategy can operate inside the drawdown constraints without requiring excessive position size.

What Is Funded Trading?

This is the stage after satisfying the relevant firm's evaluation requirements.

The exact structure varies significantly between prop firms.

Even then, I don't consider the experiment successful simply because an account receives a funded label.

My meaningful milestone is an actual payout.

Why Can Results Be Different?

There are many reasons.

Historical data isn't live execution.

SIM fills aren't necessarily identical to real fills.

Slippage exists.

Commissions exist.

Market liquidity changes.

Latency exists.

Software can fail.

Internet connections can fail.

And strategy behaviour can change as market conditions change.

That's why each stage of this experiment matters.

How I'll Measure Whether the Strategy Is Working

The easiest number to look at is net profit.

It's also nowhere near enough information.

Net Profit

Obviously, I want the strategy to make more than it loses.

But a strategy that makes $5,000 while experiencing $10,000 of drawdown isn't particularly useful for a small account.

Profit needs context.

Maximum Drawdown

This is one of the most important statistics I'll monitor.

The first five-day SIM test produced approximately $301 of maximum drawdown using two MNQ contracts.

As I move to one MNQ, I'm particularly interested in how drawdown behaves over a much larger sample.

Win Rate

The initial test produced a 65.22% win rate.

That's encouraging.

But I'm not designing the strategy around maintaining a particular win percentage.

If the average winner remains substantially larger than the average loser, the system doesn't necessarily need an extremely high win rate.

Average Winner vs Average Loser

The first test produced:

Average winner: $97.78

Average loser: $57.13

That gave an average winner-to-loser ratio of approximately 1.71.

I'll continue monitoring this closely.

Profit Factor

The initial profit factor was 3.21.

Again, that's excellent for this small sample.

I don't expect to assume that number will remain at 3.21 indefinitely.

As the number of trades increases, I'll get a much better idea of what the strategy's normal performance actually looks like.

Consecutive Losses

The initial test experienced a maximum of five consecutive losing trades.

This statistic matters because losing streaks affect both account drawdown and human behaviour.

A strategy can be profitable overall and still experience uncomfortable sequences of losses.

The Biggest Winners

This may eventually become one of the most important statistics in the entire experiment.

My hypothesis relies partly on giving successful trades the opportunity to expand.

Therefore, I want to know:

What percentage of total profit is generated by the largest 5%, 10% and 20% of trades?

If a relatively small number of large winners account for a substantial portion of the strategy's profitability, cutting those trades short could fundamentally damage the strategy.

That is exactly the sort of thing I want the data to reveal.

Changes I've Made to the Automated Strategy

I want this section to function as a public development log.

Earlier Version — Bar-Close Trade Management

My earlier implementation relied more heavily on completed candles for trailing decisions.

This could allow substantial intrabar profit to disappear before the management logic reacted.

September 2026 — Tick-Based Trade Management

I changed the strategy so that active trades can be managed using incoming tick data.

The objective is to react more quickly when a trade has moved sufficiently far in my favour.

September 2026 — 150-Tick Initial Stop

I've also moved toward a wider initial stop combined with smaller position sizing.

The current default is 150 ticks, equivalent to 37.5 Nasdaq points.

September 2026 — One MNQ Evaluation Size

Despite testing with two MNQ contracts in SIM, I'm reducing the intended evaluation size to one MNQ.

The objective is survival and data collection rather than maximizing short-term dollar returns.

Future changes will be added here rather than rewriting the history of the strategy.

What Could Go Wrong?

Plenty.

That's another reason I'm running the experiment publicly.

The Strategy Could Be Overfit

The historical behaviour I've observed may not continue.

The Sample Is Still Tiny

Forty-six trades tell me very little about how a strategy will behave over hundreds or thousands of trades.

Market Conditions Change

A strategy that works during a trending period could struggle during a different environment.

Slippage Could Affect Results

Tick-based trade management may look excellent under simulated conditions but behave differently when real orders have to be modified and filled.

The Losing Streak Could Be Much Larger

Five consecutive losses is simply the largest streak in the initial sample.

There's no reason to assume five is the maximum possible losing streak.

I Could Interfere

This one is important.

Even with an automated system, I can still interfere by increasing size, disabling the strategy, manually closing positions or changing parameters.

For the results to mean something, I need to document when that happens.

The Strategy Could Fail Completely

That's possible.

If the strategy fails the evaluation, I'll publish that.

If I change something and make the results worse, I'll publish that too.

A useful experiment can't only record the outcomes I like.

My Goal for This Automated Trading Experiment

Ultimately, I'm not trying to prove that automated trading is easy.

I'm trying to answer a narrower question:

Can I develop an automated futures trading strategy that survives real trading constraints and produces repeatable results without requiring excessive risk?

The progression is straightforward:

SIM Testing → Prop-Firm Evaluation → Funded Account → Payout → Repeatability

I'm currently near the beginning.

The first five-day simulated test produced +$2,019.50.

That's encouraging.

But it's not the finish line.

It's the starting line.

I'll continue updating this page as the strategy progresses.

Automated Futures Trading Strategy FAQ

What is an automated futures trading strategy?

An automated futures trading strategy is a set of programmed rules that can identify trading conditions and perform some or all of the trading process automatically.

Depending on the system, automation can include entries, stop-loss orders, profit targets, trailing stops, position management and exits.

My current system automates both trade execution and management.

Can futures trading be automated?

Yes. Futures strategies can be automated through trading platforms capable of running programmed trading systems.

The degree of automation varies. Some traders automate only trade management, while others build systems capable of entering and managing positions without manual intervention.

What is an automated futures trading bot?

A futures trading bot is software that uses predefined logic to perform trading actions automatically.

The term "bot" is often used interchangeably with automated strategy, algorithm or trading system, although technically there can be differences between these implementations.

Is automated futures trading profitable?

Automation doesn't automatically create profitability.

An automated strategy can execute bad trading rules just as consistently as it can execute good ones.

Profitability depends on the underlying strategy, market conditions, execution, transaction costs and risk management.

My experiment is specifically designed to determine whether the strategy I'm developing continues performing as it moves from simulation into more realistic trading conditions.

What is MNQ?

MNQ is the Micro E-mini Nasdaq-100 futures contract.

It provides exposure to the Nasdaq-100 at a smaller contract size than the E-mini Nasdaq-100 contract, NQ.

I'm currently using MNQ because the smaller size gives me considerably more control over the dollar risk of each trade.

Why am I using one MNQ contract?

Risk control.

My initial SIM experiment used two MNQ contracts, but the next stage is focused on surviving a $25,000 evaluation rather than maximizing profit.

With my current 150-tick initial stop, one MNQ represents approximately $75 of initial market risk before trading costs.

Can trading bots be used with futures prop firms?

Some futures prop firms permit automated trading while others have restrictions around particular forms of automation or trading behaviour.

Rules can also change.

Before using an automated system with any prop firm, traders should check the firm's current terms and account rules rather than assuming automation is permitted.

Is automated trading better than manual trading?

Neither is inherently better.

Manual trading allows the trader to incorporate discretion and information that may not exist in programmed rules.

Automation provides consistency and can react to predefined conditions without requiring the trader to manually execute every action.

My own interest in automation comes largely from wanting to reduce inconsistent execution rather than believing computers can magically predict markets.

Does automated trading eliminate emotion?

Not completely.

Automation can remove emotional decisions from individual trade execution, but the person running the strategy can still change settings, increase position size, turn the strategy off or manually interfere.

The psychological element doesn't disappear.

It moves.

Why use tick-based trailing instead of waiting for a candle to close?

A significant price movement can occur inside a candle and disappear before that candle closes.

Tick-based management allows my strategy to evaluate its trailing conditions while the movement is happening rather than only after the completed bar.

Whether this ultimately improves live performance is one of the things I'm testing.