Why a Good Forex EA Can Become a Bad EA at the Wrong Broker
The hidden impact of spread, commission, slippage, execution and liquidity on automated trading
There is a question that I have heard many times over the years: “Which broker is the best for this EA?”
I used to think this was a fairly simple question. After many years of developing and running automated Forex strategies, I no longer think it is.
The more accurate question is probably: “Which broker provides the right trading environment for this particular strategy?”
That sounds like a small difference in wording. In practice, it can make a very big difference.
In my previous articles, I wrote about the lessons we learned from more than ten years of developing and running automated trading systems, and then about how we approach the selection of currency pairs.
The first article focused on why an EA should not be viewed as an isolated piece of software.
The second article looked specifically at why choosing the right currency pairs is much more complicated than simply selecting the pairs with the best backtest results.
This time, I want to focus on another part of the same equation: EXECUTION.
And this is where the broker becomes important.
The EA does not trade the backtest
This may sound obvious, but I think it is one of the easiest things to forget when developing an automated strategy. A backtest gives us a simulated trading environment. The EA sees historical prices and tries to reproduce its decisions according to the available data and testing assumptions. But when the EA is running live, it is dealing with something very different.
It has:
- a particular broker;
- a particular price feed;
- a particular account type;
- a particular spread;
- a particular commission;
- a particular server;
- a particular execution model;
- real liquidity;
- real slippage;
- and real market conditions.
The algorithm may be exactly the same. The environment is not. This is why I have gradually stopped thinking about an EA and a broker as two completely independent things. For a short-term automated strategy, they can become parts of the same system.
Spread is more important than it looks
Let's start with the most obvious factor: SPREAD. Everyone knows that a lower spread is generally preferable.
But the important question is not simply: “What is the average spread?”
We also need to know when that spread occurs. Imagine two brokers.
Broker A has a relatively stable spread throughout the trading period.
Broker B has a very attractive average spread, but occasionally widens considerably during the exact period when the EA is looking for opportunities.
On paper, Broker B may look competitive. For the EA, it may be a completely different story. This is especially relevant for strategies that operate during specific trading sessions or at specific times of the day. The average spread over 24 hours can tell us surprisingly little about the spread during the actual trading window.
That is one of the reasons why, when testing our own systems, we became interested not only in average spread but also in the distribution of spread during the hours when the strategy actually trades.
Commission changes the mathematics
Spread is only one part of the cost. COMISSION matters too.
For a longer-term position, a few tenths of a pip in transaction costs may not be particularly important. For a short-term strategy, it can become a significant part of the expected result.
Consider a simplified example.
Suppose a strategy has a theoretical gross advantage of 1.5 pips per trade.
If the combined effect of spread, commission and average slippage consumes 1.2 pips, the remaining statistical advantage is very different from what the backtest may initially suggest.
And this is before considering occasional periods of much worse execution. This is why I prefer to think about net expectancy rather than gross performance. The strategy does not receive its backtest profit. It receives whatever remains after the costs of actually trading.
Slippage is not just a technical inconvenience
SLIPPAGE is another factor that is easy to underestimate.
A difference of 0.1 or 0.2 points may seem almost irrelevant when looking at a single transaction. But automated systems can execute a large number of transactions over time. Small differences accumulate.
There is also another question that I find more interesting: “Is slippage symmetrical?”
In other words, does the strategy experience positive and negative slippage in roughly the same way?
Or does the actual execution tend to be worse in situations where the strategy is trying to enter or exit?
This matters because the average slippage figure alone may not tell the whole story.
For a strategy with a relatively small expected edge per trade, execution quality can have a meaningful impact on the final distribution of results.
The trading session changes everything
This is another reason why I don't think there is a universal answer to the question: “Which broker is best?”
The same broker can provide different practical conditions at different times of the day. And the same currency pair can behave very differently during different sessions.
Liquidity changes. Spread changes. Volatility changes. The frequency of price movements changes. Market participants change.
For a strategy that trades throughout the day, these differences may average out to some extent. For a strategy that deliberately operates during a relatively narrow trading window, they become much more important.
This is exactly why, during the development of our own systems, we started evaluating the combination of:
EA + currency pair + trading hours + broker + execution conditions
rather than evaluating each component independently.
A 1 ms ping does not automatically mean better execution
There is another common misconception in automated trading.
People often focus heavily on LATENCY.
And yes, latency matters. But a low ping to the broker's server does not automatically guarantee better execution. The actual execution process is more complicated. There are multiple steps between the trading decision and the final execution.
The EA generates a decision. The terminal sends the order. The connection reaches the broker's infrastructure. The broker processes the order. The order is then executed against available liquidity. There can be differences at several points in this chain.
So I would not judge a trading environment simply by saying: “My VPS has a 1 ms ping, therefore execution must be excellent.”
Low latency is useful. But it is only one piece of the puzzle.
VPS location can matter too
This is why we recommend using a VPS for our automated systems.
Running an EA continuously on a personal computer introduces unnecessary variables:
- internet interruptions;
- computer restarts;
- power failures;
- unstable connections;
- and inconsistent latency.
A properly configured VPS removes many of these problems. But again, the objective is not to find the VPS with the lowest possible ping number.
The objective is to create a stable and consistent execution environment.
For a short-term automated strategy, consistency can be more valuable than chasing the last millisecond.
Demo and live trading are not the same thing
This is another lesson that became increasingly important to us. A demo account is extremely useful.
We use demo environments for many purposes:
- checking that the EA works correctly;
- verifying installation;
- testing new versions;
- checking trading logic;
- observing behavior under different conditions.
But a demo account cannot fully reproduce live trading. Real liquidity and real execution are different. Real slippage is different. The behavior of spreads can be different.
And, perhaps most importantly, there is no substitute for observing how the strategy behaves with actual trades over a meaningful period.
This is why we put much more weight on long-term live statistics than on a single impressive backtest. It is also why our own trading systems are publicly monitored.
For example, the live history of SCR_EURAUD can be independently observed through the MQL5 Signals platform.
The purpose of making performance visible is simple:
Let the trading history speak for itself.
The same EA can behave differently on different accounts
There is another detail that is sometimes overlooked. “Broker” is not necessarily enough information.
Two traders can use the same broker but have different:
- account types;
- spreads;
- commission structures;
- server locations;
- execution conditions;
- liquidity conditions;
- and trading infrastructure.
So even when two people say: “We use the same broker.” they may not actually be trading in the same environment.
This is particularly important for short-term strategies. For example, an ECN/raw-spread account with a commission structure may be much more appropriate for one strategy than a wider-spread commission-free account.
The correct comparison is therefore not simply:
Broker A vs Broker B
but rather:
Trading environment A vs Trading environment B.
What we learned from SCR_EURAUD
Our own SCR_EURAUD system is a good example of this principle.
The strategy is relatively selective and operates on specific currency pairs and trading conditions. Over the years, we tested different combinations of instruments and execution environments. Some combinations looked perfectly reasonable in theory. Others produced noticeably different live behavior.
This eventually led us to a rather simple conclusion:
Broker selection should be part of strategy validation, not something decided after the strategy has already been developed.
The current SCR_EURAUD system is built around EURAUD and AUDCAD, while its diversified version, SCR_EURAUD_advanced, uses a broader portfolio.
The systems are based on our own SCR_NightScalper Expert Advisor, and the execution environment remains an important part of how we evaluate the overall setup.
I don't mean that a particular broker can magically make a bad strategy profitable. It cannot. A poor strategy remains a poor strategy. But a strategy with a genuine statistical edge can lose part of that edge if the execution environment is consistently working against it. That distinction is important.
Why we don't publish a simple “best broker” list
People often ask for a list of the best brokers for an EA. The problem is that such a list can become misleading very quickly. A broker that works well for one strategy may not be the best choice for another.
A broker that is excellent for EURUSD during the London session may not provide the same practical conditions for a strategy trading EURAUD late in the US session.
And a broker that works well today may not necessarily provide identical conditions several years from now.
This is why our own broker research is based on testing rather than simply looking at advertising claims.
We are interested in what actually happens to the strategy when it trades.
What do we actually measure?
When evaluating an execution environment for an automated strategy, I would look at much more than the advertised minimum spread.
At a minimum, I would want to understand:
Spread
What is the typical spread during the actual trading window?
Spread stability
How often does it widen, and by how much?
Commission
What is the effective cost per round trip?
Slippage
What happens to actual entry and exit prices?
Execution speed
How consistently are orders executed?
Liquidity
Does execution remain stable during the relevant market conditions?
Trading session
Are the broker's conditions suitable during the hours when the EA operates?
Infrastructure
Is the VPS-to-server connection stable and consistent?
Only after looking at these factors together can we start forming a meaningful opinion.
The important difference between a good broker and a good environment
After many years, I think this is the main lesson. There may be a broker that is objectively very good. That does not automatically mean it is the best broker for your EA. The strategy has its own requirements.
Maybe it needs:
- very tight spreads;
- low commission;
- stable overnight liquidity;
- low slippage;
- a particular trading session;
- specific account conditions;
- or reliable execution during a narrow time window.
Another strategy may have completely different requirements.
So instead of asking: “Which broker is the best?”
I think the better question is: “Which execution environment is best suited to this strategy?”
That is a much more useful question for an automated trader.
This is also why optimization never really ends
Markets change. Brokers change. Liquidity providers change. Trading costs change. Execution technology changes. And market behavior changes.
A strategy that was perfectly suited to a particular environment several years ago may require another evaluation today. This does not necessarily mean that the strategy itself is broken. It means that automated trading exists inside a changing ecosystem. This is one of the reasons we continue testing our own systems even after many years of live operation. The objective is not to constantly change the strategy. Quite the opposite.
The objective is to understand whether the assumptions that support the strategy are still valid.
Final thoughts
After spending years developing and running automated Forex systems, I have become much less interested in the question: “Is this a good EA?”
And much more interested in: “Under what conditions is this EA a good trading system?”
There is a subtle but important difference. An EA can have good logic. A currency pair can be suitable. A backtest can look robust. And yet the final live result can still be disappointing if the execution environment is wrong.
That is why I now see automated trading as a combination of several elements:
Strategy + instrument + broker + execution + costs + infrastructure + risk management.
Remove one of these components from the equation and you may get a very different result.
And this is probably one of the most important things we have learned during our years of developing automated trading systems.
A good EA does not trade in a vacuum.
It trades through a broker, on a particular account, during a particular session, under particular market conditions.
And sometimes, the difference between a good live system and a disappointing one is not the algorithm at all.
It is the environment in which the algorithm has to work.

