An Honest Take on Algorithmic Trading
I still don't fully know what I'm doing in algorithmic trading. But I know a lot more about what doesn't work than when I started. Here's an honest take on the journey from complete beginner to... slightly less confused.
Expect to Fail. A Lot.
The first thing you need to accept: you will fail. Then you'll recover. Then you'll fail again. Then recover some more. And that's just learning the fundamentals.
This isn't like other software engineering domains where you can read documentation, follow best practices, and ship working code. In algo trading, the market is constantly telling you that you're wrong. Your job is to figure out how you're wrong, fix it, and prepare to be wrong in a new and exciting way.
The failure rate in this field is staggering. Most strategies don't work. Most ideas that sound brilliant at 2 AM turn out to be garbage when you actually test them. You'll spend weeks building something only to watch it fall apart the moment you run proper validation. That's normal. That's the process.
What makes it harder is that failure in algo trading isn't always obvious. In regular software, a bug crashes your app. You see the error, you fix it, you move on. In trading, a broken strategy might just slowly bleed money for months before you realize something is fundamentally wrong. Or worse - it might make money for a while due to pure luck, convincing you that you've figured something out when you haven't.
The emotional toll is real. You'll question your intelligence. You'll wonder if you're wasting your time. You'll see other people on Twitter claiming massive gains and wonder what they know that you don't. (Spoiler: most of them are lying or lucky.)
If you can't stomach that cycle, this isn't for you. The people who succeed are the ones who treat every failure as data, not as a personal attack on their intelligence. They keep detailed notes on what went wrong. They build systems to fail faster and cheaper. And they understand that every dead-end strategy teaches you something about how markets actually work.
The learning compounds. Your tenth failed strategy will fail faster and teach you more than your first. That's progress, even when it doesn't feel like it.
The Hello World Trap
When I started, I believed in the simple strategies. Moving averages. Momentum. Mean reversion. The strategies you find in every trading book and YouTube tutorial.
Here's what nobody tells you: these are the "hello world" of algorithmic trading. They're the equivalent of the todo app in web development. They exist to teach you concepts, not to make money.
Think about it. If crossing a 50-day moving average over a 200-day moving average actually worked, every retail trader would be driving a Lambo. These strategies have been around for decades. They've been tested by millions of people. They've been written about in hundreds of books. If there was easy money there, it would have been extracted long ago.
The market is a zero-sum game (actually negative-sum after fees). For you to make money, someone else has to lose it. So ask yourself: who is on the other side of your SMA crossover trade? Who's the sucker selling to you when the 50-day crosses above the 200-day? It's probably not a sucker at all. It's probably a sophisticated market maker or a fund that's hedging a completely different position. They're not losing money to your "golden cross."
SMA crossovers, RSI mean reversion, basic momentum - these are teaching tools. They help you understand how to structure a trading system, how to handle data, how to think about entries and exits. They teach you about backtesting frameworks, position sizing, and risk management. That knowledge is valuable. But the strategies themselves are not edge. They never were.
I spent months testing these approaches. Momentum looked great in backtests - until I ran out-of-sample validation and watched the returns collapse by 90%. Mean reversion generated beautiful equity curves - across three trades in two years. Not enough data to know if it was skill or luck. (It was luck.)
The real world markets are not simple. They're adaptive. They're adversarial. They're filled with participants who are smarter, faster, and better capitalized than you. If a strategy is simple enough to explain in a YouTube video, it's simple enough for everyone to trade, which means the edge has been competed away.
That doesn't mean you shouldn't learn these strategies. You absolutely should. They're foundational. But learn them like you'd learn a programming language's "hello world" - as a stepping stone to something more sophisticated, not as a destination.
Choose Your Poison Carefully
Here at Alpha Neuron, I'm completely uninterested in intraday timeframes. I focus on swing trading - daily charts and above.
Why? The answer is simple and subjective:
In this business, you don't need to be fast. You just need to be sure and handle risk well.
The biggest problem with minute-to-hourly timeframes is that you're exponentially increasing your algo's vulnerability to transaction costs and slippage. Every trade eats into your edge. The more you trade, the more you pay. A strategy that looks profitable with 0.1% transaction costs might be a money incinerator at 0.3%. And when you're trading hundreds or thousands of times per day, those costs compound brutally.
Slippage is the silent killer. Your backtest assumes you got filled at the price you wanted. Reality is different. By the time your order hits the exchange, the price has moved. The more frequently you trade, the more this hurts you. In backtests, slippage is a rounding error. In live trading, it's often the difference between profit and loss.
But here's the real issue: you've decided to pick fights with HFT.
Last time I checked, these guys have tuned everything for speed. Verilog-powered trading bots running on FPGAs - we're talking hardware-level optimization, not software. Servers colocated in the same building as the NYSE, sometimes in the same room. Microwave towers and laser links for shaving milliseconds off communication times. Billions of dollars in infrastructure just to be slightly faster than the competition.
It doesn't matter if you write your code in Rust or C++. It doesn't matter if you optimize every function and eliminate every allocation. You're not going to beat hardware specifically designed to be faster than you. Your Python bot running on AWS isn't competing. It's not even in the same sport. It's like showing up to an F1 race on a bicycle.
I know I can't win that fight, so I'm not going to take part in it. Let the big boys compete there. (I'm talking about you, Citadel. And Jane Street. And Virtu. And the dozens of other firms with deeper pockets and smarter engineers than me.)
This means I don't write scalpers. I don't write market makers. What's the point of trying to capture a good spread when HFT will front-run you every single time? They see your order coming. They adjust their prices before you can blink. The edge you thought you had evaporates before your order even fills.
Even the crypto markets now - which used to be the wild west where retail could compete - are overrun by these HFT hedge funds. They set up shop on every major exchange. They arbitrage across venues faster than you can refresh your browser. The days of easy crypto scalping are over.
The funny thing is that scalping code isn't even that complex. The strategy logic is straightforward. Market making is conceptually simple - buy the bid, sell the ask, pocket the spread. But good luck actually getting your orders filled at the prices you want. Good luck making an actual trade that captures the edge you backtested. The execution is everything, and execution at sub-millisecond speeds requires resources you don't have.
By moving to longer timeframes, I'm opting out of that arms race. On daily charts, whether I execute at 9:30 AM or 9:35 AM doesn't matter much. A few basis points of slippage on a trade I hold for weeks is noise. I'm competing on analysis and prediction, not on speed. That's a game I might actually be able to win.
Pick your timeframe carefully. Pick battles you can actually win. And be honest with yourself about what resources you actually have.
Backtests Are Unit Tests
Here's something I wish every trading book would say upfront: a backtest only tells you that your strategy is computationally correct.
That's it. That's all it proves.
A good backtest does not tell you the algorithm is profitable in the current market. It does not tell you the strategy will work going forward. And most importantly, it does not give you proof that putting it live won't blow up your account. Historical performance is not indicative of future results - you've seen that disclaimer a thousand times, but have you actually internalized it?
I think of backtests like unit tests for a strategy. They can show that your code does what you think it does. They can confirm that given a certain historical market pattern, your algorithm would have traded in a certain way. Unit tests verify that add(2, 2) returns 4. Backtests verify that your strategy would have bought AAPL on March 15th, 2023 given the conditions you specified.
But a passing unit test doesn't mean your software is production-ready. You still need integration tests, end-to-end tests, staging environments, and careful production rollouts. And a good backtest doesn't mean your strategy is ready for real money. You need out-of-sample testing, walk-forward analysis, Monte Carlo simulations, and extended paper trading.
The seductive danger of backtests is how convincing they look. You can generate beautiful equity curves. You can show Sharpe ratios that would make Renaissance jealous. You can produce statistics that look rock solid. And all of it can be completely meaningless because you've inadvertently overfit to historical noise.
Overfitting is insidious. Every parameter you tune, every filter you add, every threshold you adjust - each one increases the risk that you're fitting to the specific quirks of your historical data rather than capturing genuine market dynamics. Your strategy isn't learning to trade. It's memorizing the answers to last year's exam.
Funny thing is, most books recommend backtests as if they're the final validation step. Run a backtest, check the Sharpe ratio, and if it looks good, deploy it. This is terrible advice. Backtests are the first step. They're a sanity check, not a stamp of approval.
What comes after backtests? At minimum:
-
Out-of-sample testing - Hold back data that your strategy has never seen. Train on 2015-2020, test on 2021-2023. If performance collapses, you've overfit.
-
Paper trading - Run your strategy live with fake money. Experience real market conditions, real latency, real slippage. This is where beautiful backtests go to die.
There's more to a proper validation pipeline than just these two steps, but I'll save the details for another post. The point is that backtesting alone is nowhere near sufficient.
Nothing - and I mean nothing - can replace systematic algorithm evaluation and paper testing with live market data. The market you're backtesting on no longer exists. The future market will be different in ways you can't predict. The only way to know if your strategy works is to test it in conditions as close to real as possible.
If your backtest looks amazing, that's not a signal to deploy. That's a signal to be suspicious. Question it. Assume you made a mistake. Look for bugs. Check for look-ahead bias. Verify you're not using future information to make past decisions. And then, after all that, paper trade it for months before risking a single dollar.
The Strategy Is Only One-Third of the Battle
Here's something interesting: you could have a god-tier algorithm. Maybe something leaked from Renaissance Technologies. The holy grail of trading strategies, handed to you on a silver platter.
That's only one-third of the war won.
Most beginners obsess over the strategy. They think the secret to making money is finding the right indicator, the right machine learning model, the right entry signal. They spend months tweaking parameters, adding features, optimizing for Sharpe ratio. And they completely ignore the other two-thirds of the equation.
The asset universe you're applying your strategy to is extremely important. Bad selection and you'll be lucky to get positive returns with a 0.5 Sharpe ratio. It doesn't matter how sophisticated your algorithm is if you're applying it to assets that don't exhibit the patterns you're trying to capture.
Think about it like having a Formula 1 car but putting lawnmower fuel in the tank. The engine is incredible. The engineering is world-class. Every component is optimized for peak performance. But with the wrong fuel, it's not going anywhere fast. It might sputter along. It might even move forward. But you'll never see what it's truly capable of.
Your strategy is the engine. Your asset selection is the fuel. Your risk management is the driver. All three have to work together, and weakness in any one of them will destroy overall performance.
I've seen strategies that crush it on tech stocks and get destroyed on utilities. Approaches that print money on high-volatility crypto and bleed out on stable forex pairs. Momentum strategies that work beautifully on trending stocks and hemorrhage money on mean-reverting commodities. The same logic, the same code, completely different results.
Asset selection isn't just about picking "good" stocks. It's about finding assets whose behavior matches what your strategy is designed to exploit. A trend-following strategy needs assets that trend. A mean reversion strategy needs assets that oscillate. A volatility strategy needs assets with predictable vol patterns. Matching strategy to asset is half the battle.
And then there's risk management - the driver in our F1 analogy. You can have the best engine and the best fuel, but if the driver panics and crashes into a wall, none of it matters. Risk management determines position sizing, stop losses, portfolio allocation, and when to step aside entirely. It's not glamorous. It doesn't show up in exciting backtest charts. But it's what keeps you in the game long enough to realize your edge.
I've met traders with mediocre strategies and excellent risk management who consistently make money. I've met traders with brilliant strategies and poor risk management who blow up their accounts. The pattern is clear. Strategy matters, but it's not everything.
Don't fall in love with your algorithm. Fall in love with the system - strategy, assets, and risk management working as one. Optimize all three. Test all three. And remember that a weakness in any one of them can destroy an otherwise profitable approach. Algotrading is akin to designing a aeroplane - every component has to work in harmony, or the whole thing crashes.
Regime Is Everything
Market regime might be the most underappreciated concept in retail algo trading.
Some algorithms work in trending markets. Others work in sideways, range-bound markets. Very few work in both. And almost none work in regime transitions - when the market is shifting from one state to another.
This isn't just academic theory. It's deeply practical, and ignoring it will cost you money.
Think about what "regime" actually means. A trending market is one where prices move persistently in one direction. Momentum strategies thrive here - buy what's going up, ride the wave. A range-bound market is one where prices oscillate around a mean. Mean reversion strategies thrive here - buy the dips, sell the rips. These are fundamentally different environments that reward fundamentally different behaviors.
The problem is that markets switch between regimes, often without warning. The bull run you trained your momentum strategy on suddenly turns into a choppy sideways mess. Your beautiful equity curve turns into a slow bleed as you keep buying breakouts that immediately reverse. Or the range-bound market you optimized your mean reversion for suddenly breaks out into a strong trend, and you keep selling into strength, watching your losses mount as the market runs away from you.
You should absolutely test your algorithms in all major regimes:
-
Uptrends (bullish markets) - Is your strategy capturing the run-up or getting chopped out? Can it hold through normal pullbacks without stopping out prematurely?
-
Downtrends (bearish markets) - Does it know when to step aside? Can it go short effectively, or does it just avoid losing money? How does it handle the faster, more volatile nature of selloffs?
-
Sideways markets - Can it avoid death by a thousand paper cuts? Or does it keep trying to trade breakouts that fail, slowly bleeding transaction costs and small losses?
-
Regime transitions - This is the hardest part. What happens when the market shifts from trending to ranging, or vice versa? Most strategies get destroyed in these periods.
Regime detection and change point detection have entire fields of study behind them. Books, research papers, PhD theses. Hidden Markov Models. Bayesian change point detection. Machine learning classifiers trained on market microstructure. It's not a solved problem. The people who figure it out consistently don't talk about it publicly - that knowledge is too valuable to share.
Even if you can't detect regimes in real-time (and you probably can't, at least not reliably), you can use regime awareness to build more robust strategies. Design strategies that degrade gracefully outside their optimal regime instead of blowing up spectacularly. Use volatility filters to reduce position size when the market is behaving unpredictably. Build in circuit breakers that reduce exposure when drawdowns exceed expectations.
Market regime also powers your evaluation. If you only backtested in a bull market, you have no idea how your strategy behaves in a bear market. Your 50% annual returns from 2020-2021 might turn into 50% annual losses in 2022. And by the time you find out, it's too late - you've already lost the money.
A proper evaluation framework tests across multiple regime types. At minimum, you need bull market periods, bear market periods, and sideways consolidation periods in your test data. If your strategy only works in one regime, you need to either detect that regime reliably or accept that you'll have extended periods of poor performance.
Closing Thoughts
Algo trading is a different breed of software development. It's fun. It's intellectually stimulating. It combines programming, statistics, finance, and psychology in ways that few other fields do. It will humble you faster than any code review ever could.
But it requires patience. Real patience. Not "I'll wait a week for results" patience, but "I'll spend a year learning before I risk real money" patience. The people who succeed in this game are the ones who treat it like a marathon, not a sprint. They're okay with slow progress. They're okay with extended periods of confusion. They understand that mastery takes years, not months.
And it requires a willingness to fail. Not just accepting failure when it happens, but actively seeking it out. The faster you can fail, the faster you can learn. The more strategies you can prove don't work, the closer you get to finding one that does. Every dead end is data. Every blown backtest is a lesson.
So keep building algos. Build lots of them. Build them knowing most will fail. Build them anyway.
And when you get a good backtest all of a sudden? Question it. Question it hard. Assume you made a mistake. Assume there's a bug. Assume you're overfitting. Assume there's look-ahead bias you haven't noticed. Assume the edge isn't real until you've proven otherwise with rigorous out-of-sample testing and months of paper trading.
The default assumption should always be that your strategy doesn't work. The burden of proof is on you to demonstrate that it does. And "it looks good in backtests" is not proof. It's not even close.
Most importantly: don't quit your day job.
Seriously. Don't do it. I know it's tempting. I know the dream of financial freedom is seductive. I know you want to believe that you've figured something out. But the graveyard of retail traders is filled with people who quit their jobs too early, who risked money they couldn't afford to lose, who confused luck with skill.
Keep your stable income. Build your algos on the side. Paper trade for months - not weeks, months. And only start thinking about trading real money when your live P&L positively surprises you. Not when your backtest looks good. Not when your paper trading has a few winning trades. When you have a statistically significant track record, in multiple market conditions, over an extended period of time.
If that never happens, you've lost nothing but time and maybe some AWS bills. You still have your job. You still have your savings. You've learned a ton about markets, programming, and statistics. That knowledge is valuable even if you never trade successfully.
If it does happen - if you actually find something that works, that survives all your tests, that makes money consistently in live paper trading - you'll know. And you'll have the confidence of actual results, not just backtest fantasies.
Until then, keep building. Keep failing. Keep learning. Stay humble. Stay skeptical. And remember that the goal isn't to get rich quick. The goal is to build something sustainable, something robust, something that can survive the inevitable surprises the market will throw at you.
That's the game. It's a long game. Play it accordingly.
These are personal observations from someone still figuring it out. I don't have all the answers. I'm not consistently profitable yet. But I know a lot more about what doesn't work than I did when I started, and that's progress. Your mileage may vary, but the lessons probably won't.