Automated Trading: How I Turned $100 into $100.77

Background

I don't have a ton of formal trading experience. Most of my "trading" before this was impulse-buying crypto or tinkering in my ROTH IRA. Every day, my apps would ping me:

"BTC is up 10.5% in the past 24 hours — should I buy?"

"BTC is down 7.4% — hmm, maybe now?"

The thing is, I wasn't even planning on buying Bitcoin in the first place. These notifications were driving impulsive decisions.

I realized the only way to get ahead (or at least stop losing sleep over it) was to automate trading. Let the system decide, not my impulses.

Technologies Used

Being a software developer made the technical side pretty straightforward. I've been working in automation for my day job, so I could leverage a lot of that experience.

And yes — I know that there are trading bots out there that you can pay to use, but what's the fun in that? By building my own trading system, I'm cutting out unnecessary costs, retaining full control over my system, and learning a whole lot about development and trading.

The core of the system runs on Node.js, written in TypeScript, and deployed in Docker containers. Docker gives me isolated, reproducible environments, so the bots run consistently whether I'm at home or traveling.

For persistence and multi-bot safety, I use Redis. This ensures the bots always know the current state of each position, including stop-losses and take-profits, even if a bot restarts.

To actually place trades, I use Alpaca, a developer-friendly brokerage platform. It supports paper trading, real trading, and allows me to automate both stocks and crypto programmatically.

The Setup

I split the system into two bots: a Buyer and a Closer.

Buyer Bot:

Pull data – Grab recent OHLCV candles for all symbols on my watchlist. (Candles are a standard way to track price movement over a time period — open, high, low, close, and volume.)
Run evaluations – Each symbol is scored using a layered analysis system (more on that below).
Execute trades – If a symbol passes the evaluation, the bot places a buy order and sets a stop-loss and take-profit.

Closer Bot:

Pull held positions – Check all positions with their stop-loss and take-profit thresholds.
Check current price – Decide whether to hold or sell.

It's really that simple — like a human brain asking: "Should I buy this?" and "Should I sell this?"

Both bots run independently on cron-like schedules. I currently have the Buyer running every fifteen minutes, and the Closer bot is running every minute. This could change down the road, but I'm experimenting with this right now.

This keeps the system responsive without hammering the API or making erratic trades.

Layered Analysis & Scoring

The core of the evaluation process is a layered scoring system designed to mimic how professional traders think (according to online tutorials).

Trend Layer: Understand the macro market direction using moving averages and trend strength indicators.
Momentum Layer: Time entries and exits with RSI, MACD, Stochastic, and other momentum indicators.
Volatility Layer: Manage risk using ATR, Bollinger Bands, and volatility thresholds to determine position size.
Volume Layer: Confirm that moves are real, avoiding false breakouts with volume analysis.

Each layer is weighted, and only trades above a certain confidence threshold are executed. This explains why the system sometimes sits idle — the market simply doesn't meet the quality standards.

Introducing Machine Learning

Initially, my evaluation system was simple: traditional indicators like SMA, EMA, RSI, MACD, etc. I built a scoring system based on these, which worked okay, but I quickly realized that real trading patterns require more nuance.

Humans can recognize patterns based on these indicators — so why not train a model to do the same?

I built machine learning models in Python to filter out better trading opportunities. These models were backtested against historical data and hit around a 60–70% success rate, which is typical for professional investment firms.

I hosted the models on an on-prem API and connected it to the Buyer bot. The bot can fall back to traditional calculations if the API isn't available, keeping the system robust.

Risk Management

One of the biggest lessons I've learned is that protection comes first. My bots use:

ATR-based position sizing – Volatility-adjusted allocation to avoid oversized positions.
Dynamic stop-losses and take-profits – Stops move with market conditions to protect capital.
Max concurrent positions – Limit exposure to 10–15 trades at a time.
Fee awareness – Small accounts can lose gains to trading fees if you're not careful.

Discipline matters more than chasing gains. The system often sitting idle during down markets is a feature, not a bug.

The Results

After paper trading, I risked $100 in a real account — small enough to experiment safely.

What happened? Silence.

Before the ML model, the bots would trade constantly. Now, they paused — and that was perfect. Markets were trending down, so the system avoided unnecessary losses.

After about a week of running on a live account, trades began firing as the market recovered. Buys, sells, and more buys. As of writing, I'm up $0.77.

Tiny, yes — but it proves that disciplined, automated trading works. Small gains add up over time. Now, already I'm noticing when I get that notification on my phone that "BTC is up 5.2% in the past 24 hours", I don't even care – I know my bots have it covered.

Scaling & Future Plans

There are plenty of improvements on the horizon:

Validation: Continually check that predictions hit the ~60% success rate.
Buying power: Gradually increasing capital while keeping risk controlled.
Cloud deployment: Moving bots and the ML API off-premises to ensure 24/7 uptime.
Open source: I may release the bots publicly — they're modular and could be adapted by others.
ML SaaS: Hosting the API for others to use is a potential long-term plan.

Takeaways

This project has taught me a lot about automation, risk management, and disciplined trading. You don't need to chase big wins — slow, careful execution can compound over time.

Turning $100 into $100.77 may seem small, but it's proof that the system works, and can scale responsibly with more capital, assets, and refinement.

As always, I'll be writing follow-ups as I refine the system. Feel free to reach out with questions — I love talking about this stuff.