Why Simplicity Beats Complexity in Trading System Design
Simple trading systems outperform complex ones. Here's why and how.
Welcome to the “Systematic Trading with TradeQuantiX” newsletter, your go-to resource for all things systematic trading. This publication will equip you with a complete toolkit to support your systematic trading journey, sent straight to your inbox. Remember, it’s more than just another newsletter; it’s everything you need to be a successful systematic trader.
Introduction:
There’s a phase most systematic traders go through, usually a few months in, when they’ve learned just enough to feel dangerous. They think they’ve cracked the system development code and are on their way to creating perfect backtests.
After working on a system for awhile, the backtest doesn’t look quite good enough…
So they add another indicator.
The drawdown is too deep…
So they stack another filter on top.
The Sharpe ratio isn’t high enough…
So they optimize a few more parameters.
If that sounds familiar, you’re in good company. I did all of it too. And it took me years to understand what was actually happening: I was confusing excess complexity with effort, and excess effort with progress.
In this article, I’m going to make the case that simplicity in trading systems is the ultimate goal. Here’s what we’ll cover:
The three phases of a systematic traders journey
Why complexity creeps in (and why it feels like the right thing to do)
What complexity actually costs you in backtest reliability
What “elegant” system design actually looks like in practice
The practical rules I use to keep my systems simple
Why simplicity matters even more at the portfolio level
Let’s jump in.
The Three Phases:
Most traders start out completely unaware of the complexities in their systems and processes. They don’t even know what they don’t know.
They think the solution to their poor trading performance is to pile on more complexity. (Remember that phase when you thought adding more indicators and parameters, i.e. complexity, to your trading system would make it better?).
I know this process intimately because I’ve lived it. My first “trading system” was a stitched together Python code from stack overflow forums, and I had no idea what any of the Python functions did because I had never coded before.
The baseline system code bought a stock when a 1-minute candle closed below the lower Bollinger Band and sold when price bounced back to the mid Bollinger Band.
No backtesting.
No out-of-sample testing.
No idea if it would work.
No real edge.
Just a pile of code I’d convinced myself “had to work.” And kept adding more and more rules and parameters and complexity to fine tune it over time. Luckily, the code was so fragile that it never actually successfully placed a trade. It nearly always crashed first.
But I thought the more complex I made it, the better it would be. I know now that’s wrong.
That was Phase 1. Phase 2 was automating hundreds of indicator combinations overnight and cherry-picking the ones that showed promising in-sample and out-of-sample results. This is called data mining.
Sounds reasonable, right?
An automated process to discover trading systems for you.
I thought so too (little did I know…).
I ended up losing over $20,000 trading those cherry picked data mined systems live.
I thought that having an automated way to spit out trading strategies would make it impossible for me to fail. I thought if it was always pumping out new ideas, then I could always be trading better and better strategies.
I quickly learned that the automation wasn’t actually capturing any real edge; it was finding lucky parameter / rule combinations at scale, and I had no way to tell the difference.
Phase 3, the final phase that only few systematic traders eventually reach (most have quit by now), is the realization that the goal was never more complexity, or autonomous solutions, or data mining, or perfect backtests, or beautiful equity curves.
The goal is the simplest viable model of a real and understood market effect.
Everything else is noise and indicator soup.
Why Complexity Feels Like a Solution:
The instinct to add complexity is completely understandable. When a system isn’t performing well (live or in a backtest), it genuinely feels like the answer is to refine it.
Add a filter to cut out bad trades, add a condition to improve entry timing, tune the parameters until the equity curve looks just right. It feels like progress, but in reality, it’s detrimental.
The problem is that this instinct is backwards. Every rule you add is another degree of freedom the system can use to fit to noise in your training data. Every parameter you tune is another way the system can accidentally fit to some quirk that happened once in 2009 and won’t even happen again.
A system with 15 parameters is almost certainly capturing a lot of noise rather than just the underlying market effect you were trying to model.
Think about it this way: if your system is trying to capture the tendency of strong stocks to keep trending, that’s a simple idea. A simple model of a simple idea should work.
The moment you start stacking multiple momentum filters, on top of volatility filters, on top of regime detection, on top of breakout conditions, on top of sector constraints etc., you’re no longer creating a model to capture your desired effect in a robust way.
Instead, you’re modeling to the specific historic sequence of data you trained the system on. And specific histories don’t repeat.
It’s fine to have some of these layers in a system, but creating a system with 10 rules, 20 parameters, and a heavily used optimizer is a major problem.
What Complexity Actually Costs You:
The damage from system complexity shows up in several places, and most of them are invisible in the backtest.
Curve fitting risk goes up. I’ve looked at this directly in my own development process. A system with 3 parameters has a much lower likelihood of accidentally producing a good result than a system with 50 parameters. Simple systems are inherently harder to overfit. Less room for the optimizer to work with means less room for the optimizer to mislead you.
The backtest becomes less trustworthy. When a system has 10 rules and performs well, how do you know which rules are actually doing the work? How do you know which rules are truly meaningful and which ones just happened to work on the data you trained on? You don’t. Then when you go live, you have no idea what’s actually making the system work (or more likely, not work).
Bugs multiply. More code means more things that can go wrong. I’ve been doing this for over 6 years and still sometimes find subtle mistakes in my systems. A trading system you can explain in plain English to someone who doesn’t trade is a system you can actually audit. A 10,000 line monster of a system code, full of edge cases and nested conditions, is not.
Trust collapses in drawdowns. This is the one that really hurts. When a complex system hits a drawdown, you have no idea which of your 15 rules is the culprit. Is this normal behavior? Is something broken? Is the edge gone? You can’t tell. A simple system that you understand is much easier to diagnose. You know what it’s supposed to be doing and you can verify whether it’s still doing it.
What Simple Actually Looks Like:
The more complex a system is, the greater the chance something goes wrong. Whether it’s curve-fitting, an overlooked assumption, a bug in the code, or any number of other issues.
That’s why the first step in any of my processes whether it’s system development, portfolio construction, or anything in between is to eliminate needless complexities. I do this iteratively: after each major step in whatever I’m working on, I go back and review to strip out any unnecessary complexity that might have crept in.
My trading systems are simple and straightforward. I could explain the concepts and rules to a child. And my audit process ensures that I strip all complexities so that it stays that way.
That doesn’t mean my systems are dumb. Simple isn’t the same as stupid. Rather, I would describe my systems as elegant. They have the minimum amount of complexity needed to capture the effect they’re designed to take advantage of, and nothing more.
Generally, higher complexity systems lead to better in-sample performance, but less stability out of sample. Lower complexity means slightly lower in-sample performance but more stable results where it matters; in live trading.
Practical Rules for Keeping Systems Simple:
A few things I actually do that keep complexity in check.
Start with the mechanism, not the indicator. Before I ever write a line of code, I ask: why should this effect exist? What is the real-world force that creates this pattern? If I can answer that in plain English, I can usually build a simple system to capture it. If I can’t, if the answer is “the MACD said so”, then I am very skeptical of if that edge actually exists. It’s likely just noise that happened to look like an edge.
Fewer rules, then test. My first version of any system is always the bare minimum to test the idea. If the concept has any merit, even a stripped-down version should show some signal. If I need 8 rules before the backtest shows any positive expectancy at all, that’s a red flag. The signal should be obvious enough that a super simple initial model can roughly find it.
Parameter sensitivity is one of your best robustness tests. After building a simple system, I want to see that the results are roughly stable across a reasonable range of parameter values. If the system only works with very specific values, that’s usually due to curve fitting to noise rather than capturing a real edge.
Always be simplifying. Throughout the system development phase I review the current code base periodically and ask: do I still need all of this? Sometimes a rule that made sense when I added it no longer adds value once the core system has matured. If that’s the case, in the trash the extra complexity goes. Less complexity, less room for fragility.
Why This Matters Even More at the Portfolio Level:
If you trade a single system, simplicity is important. If you trade a portfolio of many systems like I do (25+ live systems at the moment), then simplicity is probably the most important factor in your setup.
Every rule in every system multiplies across the portfolio. More parameters across more systems means more things that can break, more things to monitor, and more ways to accidently curve fit.
Simple systems also combine better. You can understand exactly what each system is supposed to be doing and how they should interact. A portfolio of simple, elegant systems is far easier to reason about than a collection of complex, interdependent black boxes.
When something goes wrong in the portfolio (and eventually something always does) simple systems give you a fighting chance of figuring out what and why.
Conclusion:
Adding more complexity to a trading system is almost always wrong. It feels like progress because it takes effort and it makes the backtest look better. But if you want your live trading results to match your backtest expectations, we need to be going in the opposite direction.
Develop the simplest viable solution of a trading system that models a real market effect. Do that 10 times. I guarantee that even though each individual system may look meh, that combined portfolio will look pretty sweet.
Complexity is where edge goes to hide and die. Keep your systems simple, keep asking why they should work, and keep stripping out anything that doesn’t have a good answer.
Simple systems are less susceptible to curve fitting. Simple systems fail in more understandable ways. Simple systems are easier to trust in drawdowns, easier to audit for bugs, and easier to combine into a portfolio that actually works.
If you found this useful and want to go deeper, the Portfolio Development Series covers exactly how I build and combine simple but elegant systems into a portfolio. You can read the first article in the series here, enjoy!
Portfolio Development Series - Part 1
Welcome to the “Systematic Trading with TradeQuantiX” newsletter, your go-to resource for all things systematic trading. This publication will equip you with a complete toolkit to support your system…