January 27


3 Huge Algo Trading Mistakes To Avoid

By Kevin Davey

January 27, 2020

algo mistakes

For most traders, algo strategy development is merely a means to an end - a necessary evil to be endured on the path to making profits. Just as spending gold is more enjoyable than panning for it, so it is with trading system development; actual trading is usually more fun than developing a trading approach.

Unfortunately, this leads traders to take all sorts of shortcuts, and make all kinds of mistakes, as they develop their trading methodology. While this makes the trader's life easier in the short run, mistakes and shortcuts inevitably come back to roost in real time trading. And the end result is usually not good.
The good news is that most traders make the same mistakes in development, and once identified, they can be overcame and corrected. Eliminating these issues won't make strategy development any easier, regretfully. Strategy development, performed the right way, becomes much more difficult when the shortcuts are eliminated.
So, what are some of the most common mistakes and shortcuts? Here are three of the most popular ones, with explanations why they are harmful, how they can be recognized, and how they can be corrected. Avoiding these common mistakes will make any trader a better creator of trading systems.

Mistake #1: Making Your Algo Strategy Too Complex
If you have been involved with trading for any length of time, you've undoubtedly come across complicated trading approaches. For a discretionary trader, this might look like the chart shown in Figure 1 below. Many indicators, many lines, and many support and resistance areas adorn each and every chart. For an algorithmic trader, a complicated approach might be thousands of lines of code, with dozens or even hundreds of variables to optimize and tweak.
Both of these approaches have one thing in common - they are extremely complicated and involved. Many inexperienced traders think this is the way to develop a system. Their thinking is that the more indicators that line up, and the better the fit of their algorithm to past data, the better off the strategy is. Nothing could be further from the truth.
The fallacy in thinking a complicated approach is better is that a superior result with historical data does not equate to real time success. In fact, constantly tinkering with an approach, adding an indicator, or inserting another rule in the algorithm to make a trading approach more complicated, usually only gives the trader a false sense of confidence. Improving and adding rules to a strategy does not mean it will work better in the future.
As hard as it is for most to believe, the simple approaches are usually the best. For a discretionary trader, a clean chart with only one or two indicators, coupled with a thorough understanding of price action and market dynamics, is always better than a chart clouded with lines and indicators. For algorithmic traders, one simple entry rule is typically better than five or ten conditions that must be satisfied for a trade to be taken.
A simple example of this is shown in Figure 2. While far from a perfect system, the strategy is very simple. Such a strategy is unlikely to be overfit to historical data, and therefore is more likely to perform in the future.

Mistake #2 - Assuming Friction Free (No-Cost) Trading
Take a look at most trading systems for sale, and you'll usually notice a small disclaimer at the bottom: commissions and slippage not included. Likewise, many do it yourself developers also ignore commissions and slippage during development. If they do include these costs, they usually underestimate the amount.
You'll hear various reasons for not including commissions and slippage. "Different brokers charge different commissions", is a common excuse. "My system uses only limit orders", is another. The real reason, though, is to make a system appear better than it really is. Profitable systems become a lot more difficult to discover when real world trading costs are added in.
For example, take a simple scalping system for the mini S&P futures. Without commissions and slippage, such a system might take 20 trades per day, and average $15 profit per trade. The trader might see the end result, $300 per day, and think that is a nice payday. But add in $5 round trip commissions, and 1 tick round turn slippage (which is probably optimistic), and the $300 per day actually turns into -$50 per day.
One hidden impact of evaluating a strategy without commission and slippage costs is that it leads the trader to take more trades than necessary. Here's an example. Suppose System A is the scalping system mentioned above. It earns $300 per day before commissions and slippage. Compare that to System B  It only trades 1 time per day, and averages $50 per trade before trading costs. Anyone evaluating both systems side by side, would surely pick System A over System B. Yet, when commissions and slippage are added in, the exact opposite is true; System B is the only worthwhile approach. It trades less, and commissions and slippage are a much smaller percentage of the gross profits.
It is critical, then, to include adequate amounts for commissions and slippage at the start of development. $5 per round turn for commissions, and 1-2 ticks round turn for slippage, is a reasonable place to begin.
Mistake #3 - Using All Your Historical Data
A third mistake many traders make during development is using all the available historical data for their testing. Most inexperienced traders will run optimizations and analysis up until the present day. The thinking usually is that the trader wants to be sure the strategy is "tuned" to the most recent data.
Of course, if the first test is a failure, the trader will go back, add a rule or a filter (thereby getting closer and closer to committing the complication mistake discussed earlier), and run through all the data again. Eventually, the trader finds something that works, and then begins to live trading. This approach, though, is almost always a recipe for real time disaster.
A much preferred, and much more difficult path, is to utilize an out-of-sample test to verify a trading system. For instance, the trader might develop a strategy over the past 10 years of data, but leaving the most recent year of data untouched and untested. Once development is complete, the strategy is run on the unseen (out-of-sample) data. If the system performs acceptably, then it can be considered for live trading.
Taken one step further, walkforward testing can be used, which combines multiple out-of-sample periods. Such an approach is much more likely to lead to real money success, since any resulting equity curve is entirely composed of out-of-sample results.
The pitfall to walkforward or out-of-sample testing is that once the test is run once, any further tests will not truly be "out-of-sample." So, it is easy to inadvertently make an out-of-sample test an in-sample test, if you perform it multiple times. But performing out-of-sample tests is much better than optimizing on all data.
Creating a viable trading strategy is extremely difficult. In fact, many traders are never even able to accomplish this, and many times will instead take shortcuts or make simplifying mistakes while developing a system. Certainly adding rule after rule, filter after filter, and condition after condition is easier to do than finding one simple rule that works reasonably well. Similarly, uncovering workable strategies is fairly easy, if you do not account for the grinding friction of commissions and slippage. Finally, running an optimization on all available data is also much simpler, and seemingly much more fruitful, than running laborious walk forward or out-of-sample tests.
The simple lesson in these development mistakes is this: if the approach makes finding systems easier, or always creates better backtests, it is a warning sign that something may be wrong. Proper system development is tough. Yet, in the long run, developing the correct way is always preferable to losing money in the market due to a development mistake.

-- By Kevin Davey from kjtradingsystems

Kevin Davey

About the author

Kevin Davey is a professional trader and a top performing systems developer. Kevin is the author of “Building Algorithmic Trading Systems: A Trader's Journey From Data Mining to Monte Carlo Simulation to Live Trading” (Wiley Trading, 2014.) . He generated triple digit annual returns 148 percent, 107 percent, and 112 percent in three consecutive World Cup of Futures Trading Championships® using algorithmic trading systems.

His web site, www.kjtradingsystems.com, provides trading mentoring, trading signals, and free trading videos and articles. He writes extensively in industry publications such as Futures Magazine and Active Trader and was featured as a “Market Master” in the book The Universal Principles of Successful Trading by Brent Penfold (Wiley, 2010).
Active in social media, Kevin has over 15,000 Twitter followers. An aerospace engineer and MBA by background, he has been an independent trader for over 20 years. Kevin continues to trade full time and develop algorithmic trading strategies.

  • There are of course lots more mistakes that could be avoided but I would add not rushing to start trading a new strategy. Even if a strategy passes all tests, I like letting the strategy ‘sit’ for at least 6 months (SIM trading). Get a feel for the strategy, check for code errors and having 6 months of ‘real data’ can assist in gaining additional confidence prior to placing real money to work. Frequently, I will find that those 6 months can show a performance drop off and save me from a possible losing strategy.

  • {"email":"Email address invalid","url":"Website address invalid","required":"Required field missing"}

    Learn To Code & Build Strategies
    Using EasyLanguage.