Forem: IO

"Just Automate It" — When an Engineer Builds a Trading Bot

IO — Sat, 14 Mar 2026 09:14:52 +0000

I Automated My Investments. Then Reality Hit.

When I first got serious about this, my brain immediately went to the place every software engineer's brain goes: if the rules are clear, it can be automated.

That's genuinely how I think about everything. If a process has defined inputs, defined outputs, and a logic chain connecting them, it's a candidate for code. Investing felt like it should qualify. Buy low, sell high. Use indicators to tell you when to buy and when to sell. Repeat. Where exactly is the human judgment required here?

Turns out I was asking the wrong question, but I didn't know that yet.

The Golden Cross and Why It Seemed Obvious

I started reading about technical analysis. Not books, just the usual rabbit hole. Wikipedia, Investopedia, a few StackOverflow threads where someone asked a similar question. The concepts that kept surfacing were moving averages.

The idea is simple. A moving average smooths out the noise in a price series by averaging closing prices over some window. The 50-day simple moving average of SPY on any given day is just the average closing price over the previous 50 days. As new days come in, the window slides forward. That's all it is.

The interesting part is what happens when you put two of them together. A short-period moving average (say, 50 days) and a long-period one (200 days). The short one reacts faster to recent price changes. The long one reacts slowly. When the fast line crosses above the slow line, that's called a golden cross. Supposedly bullish. When it crosses below, that's a death cross. Supposedly bearish.

The logic felt clean to me. You're essentially comparing recent momentum against longer-term momentum. If short-term prices are rising faster than the long-term average, things might be accelerating. That made intuitive sense.

I also read about EMA, the exponential moving average, which weights recent prices more heavily instead of treating all days in the window equally. The formula is recursive. Each day's EMA is a blend of the current price and yesterday's EMA, controlled by a smoothing factor based on the window size. More responsive than SMA, potentially less lag on signals. I made a mental note to try both.

And then I found RSI, the relative strength index. The math there is a bit more involved but the idea is elegant. You look at the average gains versus average losses over a 14-day window, compute a ratio, and scale it to a 0-100 range. Values above 70 are considered "overbought." Below 30 is "oversold." The theory is that extreme values mean a reversal is coming.

I immediately thought about using RSI as a filter. Only act on golden cross signals if RSI isn't already overbought. That felt like I was being smart about it. Adding constraints. Reducing false positives.

Building the First Bot

I pulled historical data using yfinance. If you haven't used it, it's a Python library that pulls from Yahoo Finance. Free, easy, works fine for daily OHLCV data going back decades. I grabbed SPY going back to 2000. That gave me two decades of data including the dot-com crash, the 2008 housing crisis, and the 2020 COVID drop.

I used pandas for the data manipulation. Computing rolling means is literally a one-liner in pandas. The SMA is just df['close'].rolling(window=50).mean(). For EMA there's a built-in .ewm() method. These are the easy parts.

The backtesting logic itself isn't much more complex. You iterate through the data chronologically. At each row, you check: did the 50-day cross above the 200-day yesterday? If yes, buy. Did it cross below? If yes, sell. At the end you compare what that strategy would have returned versus just buying and holding SPY the whole time.

My first pass used SMA crossovers, no RSI filter. I ran it and stared at the results.

The backtest showed something like 340% total return over 20 years. Buy and hold over the same period was around 280%. I was beating the market.

I remember sitting there in my apartment at maybe 11pm on a Tuesday, running the numbers again because I didn't trust them. They kept coming back the same. I added the RSI filter. The drawdowns got smaller. The return stayed competitive. Sharpe ratio went up.

This is the thing about backtesting. When it works, it feels like you discovered something real. You can see every trade laid out chronologically. There's that one trade in March 2009 where the strategy got you back in near the bottom. There's that clean exit before the 2020 crash. The chart of your portfolio equity curves nicely upward. You can point to specific moments and say, look, the signal worked here.

It genuinely looks like evidence. That's what makes it so dangerous.

What Backtesting Actually Is

I'll be honest about what I did and didn't understand at this point.

I understood that backtesting was simulated. Obviously the trades didn't really happen. But I thought that if the rules were deterministic and applied consistently to historical data, the results would be predictive of future results, assuming the underlying market dynamics didn't fundamentally change.

That sounds reasonable. It's mostly wrong, for a few reasons I hadn't fully appreciated.

The big one is lookahead bias. It's surprisingly easy to accidentally let future information contaminate past decisions in your backtest. For example, if you compute an indicator using the full dataset and then simulate trades, you've cheated without meaning to. I was careful about this one because I'd read about it.

The one I missed was overfitting. When you backtest a strategy and then tweak it to improve the results, then backtest again, then tweak again, you're fitting the strategy to the historical noise. The 14-day RSI window, the 50/200-day crossover. Why 50 and 200? Why not 45 and 180? Why not 60 and 250? I tried a few combinations and picked the ones that looked best. I didn't fully register that I was doing this. I thought I was just validating that the classic parameters worked. But the act of checking was itself a form of fitting.

There's also transaction costs. In my first backtest I didn't account for them at all. When I added a $5 commission per trade and a couple basis points of slippage, the edge shrank. Still positive, still convincing, but smaller.

And survivorship bias doesn't apply to SPY directly, but if I'd been testing on individual stocks I'd have been pulling data only for stocks that still existed. The ones that went to zero aren't in the historical dataset. Your backtests automatically avoid them.

I understood most of these things intellectually. I thought I'd been careful. I had no idea what I was walking into.

The Decision to Go Live

I set a budget. Not my whole portfolio, just a portion I could afford to lose. This felt like responsible risk management. I told myself it was tuition.

I connected my broker's API, which is straightforward with alpaca-trade-api if you're using Alpaca for US equities. They have a paper trading environment where you can run your bot with fake money against real market conditions. I did about two weeks of paper trading. Everything looked fine.

Then I pushed the go-live commit.

I remember watching the first real trade execute. SPY, market order, real money. It felt different from looking at backtest output in a pandas dataframe. There was a small adrenaline hit I hadn't expected. I'm a pretty calm person normally. I wasn't calm.

The bot ran on a cron job on a cheap DigitalOcean droplet. Every day after close it would pull the latest data, recompute the indicators, check for crossover signals, and place orders if needed. I'd get a Slack notification when a trade executed. I kept checking Slack.

At that point I genuinely believed I'd done the work. The code was clean, the logic was sound, the backtest results were strong. The gap between that confidence and what was about to happen was pretty wide.

The first few weeks were fine. Not great, not bad. The market was doing its thing and my bot was doing its thing and they weren't interacting in any dramatic way. That was actually the most misleading part. Nothing obviously wrong.

Then the choppiness started.

Next: I'll walk through what actually happened when the strategy started generating signals in a sideways market. The whipsaws, the false signals, and the moment I opened my brokerage statement and did the math on what the fees were adding up to. Spoiler: the backtest did not mention any of this.

Side Hustle Hell — The Engineer Who Tried Everything

IO — Fri, 13 Mar 2026 16:33:10 +0000

I Spent Two Years Trying to Make Money on the Side. Here's How Badly I Failed.

It's 11pm on a Tuesday. I have Binance open in one tab, a half-finished pull request in another, and a Slack notification I've been ignoring for forty minutes. My portfolio is down six percent. I have standup in eight hours.

This was my life for most of 2021.

I make decent money as a software engineer. Not "quit your job and move to Bali" money, but good money. The kind where you're not stressed about rent but you're also not building any real wealth, because San Francisco has a way of consuming paychecks that would feel enormous anywhere else. I was maxing my 401k and throwing whatever was left into a Vanguard index fund because that's what the Bogleheads subreddit told me to do.

That was fine. Responsible, even. But fine wasn't what I was after.

I wanted something that scaled. Something where I put in the work once and it kept paying. The engineer brain does this thing where it looks at every problem as a system to be optimized, and I kept looking at my income and thinking: there's only one input here. Me. That's a single point of failure. What if I get sick? What if the job market tanks? I needed another stream.

So I started trying things.

The Forex Phase

A guy in my company's random Slack channel posted about how he was making an extra two grand a month trading forex. I asked him about it, he sent me some YouTube links, and three weeks later I had a demo account on MetaTrader 4 and I was convinced I was about to become a currency trader.

I learned what pips were. I learned about the spread. I watched probably fifteen hours of content about support and resistance levels and I drew lines on charts with complete confidence that I understood what they meant.

Then I opened a real account with five hundred dollars.

I lost a hundred and forty bucks in the first week. Not because the market was crazy. Because I had a full-time job and I was trying to day trade currencies, which is insane. The yen moves when Tokyo opens. The dollar moves during the US session. The euro has its own thing happening in the morning before I'm even out of bed. Forex doesn't care about your sprint planning meeting. It just keeps moving, and if you're not watching it, you're losing.

I closed the account after about six weeks.

The Crypto Phase

This one hurts more to write about because I actually believed in it, not just as a trade but as a technology. I still kind of do. But there's a difference between believing in a technology and being a competent trader of that technology, and I confused those two things badly.

2021 was a wild time to get into crypto. Everything was going up and then everything was going down and then things I'd never heard of were going up a thousand percent and I was reading about Solana at three in the morning like that was a normal thing to do.

I bought ETH, some SOL, a little MATIC. I had a rough thesis about layer-two scaling being the future. The thesis wasn't even wrong, honestly. But I had no position sizing, no exit strategy, no risk management at all. I was just... holding things and hoping. When stuff dropped forty percent in May of that year I panic-sold half my position at the worst possible time, which is the most human thing you can do and the most expensive.

The part that really got me was the opportunity cost. I spent probably four hours a week reading crypto Twitter, which is four hours I'll never get back, and I made essentially nothing for it.

The Affiliate Marketing Detour

I'm not going to spend much time here because it's embarrassing. I built a personal finance blog. I wrote maybe eight articles. I spent two weekends getting the SEO setup right because that's the kind of thing engineers do: we perfect the infrastructure and never ship the content. The site got eleven organic visitors in its entire existence, ten of which were probably me checking if Google had indexed it yet.

The fundamental problem with affiliate marketing as a side project is that it takes eighteen months to see results, minimum, and that's if you're putting in real hours. I was putting in like three hours a week while exhausted. Content marketing rewards consistency and volume. I am consistent and high-volume at my job. I have almost nothing left after that.

So by late 2022 I'm batting zero on the side income thing. And I'm tired. Not just sleep-tired, though I was that too. Tired of starting things and not finishing them. Tired of the mental overhead. Tired of feeling like I was hustling and going nowhere.

I almost just gave up and accepted that index funds were enough. Maybe they are, for some definition of enough.

But I kept coming back to this one thought. All of my failed attempts had the same failure mode. They required my active attention during market hours, or they required consistent creative output, or they required me to be present in a way that competed directly with my job. The moment I got slammed at work, the side thing died. Every time.

What if that constraint was the actual problem to solve?

I'm an engineer. I build systems that run without me. I've written cron jobs that have been running without a single human touch for four years. I've built data pipelines that process millions of events while I'm asleep. The thing I'm actually good at, professionally, is making things that run automatically.

Why was I trying to do a job that required me to be awake and alert and watching a screen? That's not a system. That's just a second job. A worse job, with no salary and no benefits.

Investing, though. Investing has this property that most things don't: the underlying action, buying and selling financial instruments, is fully automatable. A broker with an API doesn't care if the order came from a human clicking buttons or a Python script running on a VPS at 4am. The execution is the same.

I'd vaguely heard about algorithmic trading. Quant funds, HFT, all that. I'd always assumed it was out of reach for a regular person. You needed Bloomberg terminals and PhDs and co-location servers next to the NYSE. That whole world seemed sealed off.

Then I started actually looking into it, and I realized that landscape had changed a lot. (Last time I use that word, I promise.) Brokers like Interactive Brokers and Alpaca had opened up real API access to retail traders. There were Python libraries. There were backtesting frameworks. There was an entire ecosystem of people building exactly the kind of automated systems I was imagining.

It wasn't easy. I want to be clear about that upfront because this is where a lot of these stories turn into hype. I'm not going to tell you I found a magic indicator or figured out some trick the institutions don't know. The stuff I eventually built took months to work, failed in ways I didn't expect, and still has problems I'm actively dealing with.

But the basic idea held up. If I built something solid, it could run while I was in meetings. It could place orders while I was asleep. My attention wasn't the limiting input anymore.

That realization was enough to make me actually focus for once.

I remember the specific night I decided to take it seriously. It was a Saturday in November, I think. I had a coffee that had gone cold, I was reading the Alpaca docs at my kitchen table, and I got this feeling I sometimes get at work when I'm looking at a gnarly problem and I can suddenly see the shape of the solution. Not the whole thing. Just the shape.

That's enough. That's all you need to start.

My roommate walked through and asked what I was working on. I told him I was maybe going to try automated trading. He said "isn't that what caused the 2010 flash crash" and went to bed.

He wasn't wrong, technically. But I wasn't building anything that was going to move markets. I was trying to build something that would let me not check my phone at 2pm during a code review.

Small ambitions. Good enough.

Next: I'll get into what automated trading actually is for someone without a quant background. Not the theory. The practical stuff. What a strategy even looks like when you write it in Python, why backtesting is both essential and deeply misleading, and the first mistake I made that cost me real money.