Live cohort opens Monday

Stop building backtests
Start building trading bots that actually run.

The engineering they won't teach you on YouTube. A 4-week build-along where you ship a production Alpaca bot — same architecture I run on my own paper account, every bug fix included.

$997 regular · $497 founding-cohort price · 30-day refund
Why most algo traders never go live

The brutal gap between backtest and reality

A 72% win-rate backtest means nothing if your bot dies on a network blip at 10:30 AM. Most courses stop at "look at this equity curve." That's where the real work starts.

✕

Your laptop sleeps

The Mac sleeps mid-session. Your bot lags 2 hours behind, takes zero trades, the day is dead. You don't know it happened until you check the dashboard.

✕

Alpaca returns empty bodies

The cancel-order endpoint returns HTTP 204 (no body). Your `r.json()` crashes. The whole bot dies mid-trade with stops half-replaced.

✕

Network blips kill the day

One urllib3 ConnectionError during a signal check and the whole process exits. You discover at 4pm that you never traded.

✕

Bracket orders that don't behave

OPG orders silently expire. Stop legs go to "held" status, not "new." Your dashboard says no stop — except there is one, you're just querying wrong.

This isn't theory

I run this on my own account. Every Monday.

Every bug in this course is a bug I hit in production. Every fix is the fix I shipped. I'll show you my live dashboard, my green days, my crash days, and the exact code that handles both.

72.1%
Backtest win rate
5.82
Profit factor
-1.7%
Max drawdown
6yr
Backtested data

Backtest of the School Run v8b strategy (included in the course). Past performance ≠ future results. Real-world execution typically 60–75% of backtest after slippage and missed fills.

Everything you get

The complete production stack — yours to keep

📦

The full bot codebase

school_run_live.py — the same hardened script I run. With every fix from 7 production bugs, fully commented.

📊

The smart dashboard

Flask + Chart.js single-file dashboard. Live positions, ATR trail state, closed trades, equity curve, system health.

🧪

The backtest engine

6 years of cleaned 15-min data for 19 symbols. Variant tester so you can swap entries, exits, filters and re-run in seconds.

📋

The hardening playbook

Every production bug I've hit, the symptom, root cause, and the patch. PDF reference you'll actually use.

🎬

32 video lessons

4 weeks, 8 lessons per week. Screen-recorded, no fluff. Watch in 15 hours. Build your bot in parallel.

💬

Private community

Discord for the cohort. I'm in there daily for 4 weeks. After that, lifetime access — alumni help each other.

The 4-week curriculum

From empty Alpaca account to live bot — in 4 weeks

1

Week 1 — The strategy that survives daylight

8 lessons · ~3 hours · End of week: backtest your own strategy

Most strategies look amazing in backtest and die in real life. We'll dissect why — and build School Run v8b, an ORB strategy that survives 6 years of slippage, gaps, and regime shifts.

  • Why "buy the breakout" usually fails (and what to do instead)
  • The 4 filters that turn a 55% strategy into a 72% strategy
  • Walk-forward validation that catches regime breaks
  • The give-back problem and how ATR trails solve it
2

Week 2 — Going live without blowing up

8 lessons · ~4 hours · End of week: bot running on Alpaca paper

This is the week most courses skip. Alpaca's API has 47 ways to ruin your day. We'll walk every one.

  • Bracket orders, OCO legs, and the "held" status trap
  • Position sizing under PDT and margin constraints
  • Order routing, time-in-force pitfalls, OPG expiry
  • The retry/timeout/idempotency triangle every bot needs
3

Week 3 — The dashboard that tells you the truth

8 lessons · ~3 hours · End of week: full dashboard at localhost:8080

Account.unrealized_pl returns None. The activity log lies. Yesterday's equity isn't yesterday's equity. We'll build a dashboard that surfaces the truth, not the convenience fields.

  • Reconstructing closed trades from raw fills (signed FIFO matching)
  • Computing real day P&L from last_equity (and why)
  • System health: process detection, log heartbeats, lag alerts
  • Charting intraday + multi-day equity in one continuous line
4

Week 4 — Production hardening & deployment

8 lessons · ~4 hours · End of week: bot running 24/7 on a $4/mo cloud VM

Your laptop is not a server. The final week takes you to the cloud — Hetzner, systemd, Tailscale, the works. You'll deploy, recover from a simulated crash, and walk away.

  • Provisioning a Hetzner VPS in 20 minutes
  • systemd services + timers that auto-restart on crash
  • Tailscale for private dashboard access (no public exposure)
  • The 11 production bugs and the patches that fix them — PDF playbook
Why this is different

Most algo courses sell you a backtest. This one sells you a bot.

What you actually get
Typical $497 course
Bulletproof Algo
Backtested strategy with equity curve
✓
✓
Working live code on Alpaca
✕
✓
Live dashboard with positions & closed trades
✕
✓
Production bug playbook (real bugs, real fixes)
✕
✓
Cloud deployment walkthrough (systemd / Tailscale)
✕
✓
Instructor runs the bot on their own account, publicly
✕
✓
Enroll — founding cohort

One time. Yours forever.

No subscription. No upsell. You buy it once and own everything — code, data, dashboard, future updates.

Founding cohort · 47 seats left
$497
$997 after launch
  • 4 weeks of structured lessons (32 videos, 14 hours)
  • School Run v8b — fully commented live bot code
  • Smart dashboard with all 7 production fixes
  • 6 years of 15-min data for 19 symbols
  • Production bug playbook (PDF)
  • Cloud deployment guide (Hetzner + systemd + Tailscale)
  • Private Discord — I'm in there daily for 4 weeks
  • Lifetime updates as I add new strategies
Enroll for $497 →
🛡️ 30-day money-back guarantee. Ship a working bot or refund — no questions.
Questions

Honest answers

Do I need to be a programmer?

You need to be able to run a Python script and use a terminal. If you've ever installed a Python package with pip, you're qualified. If you've never written code, this isn't for you — try a "no-code" tool first.

Will this make me money?

Maybe. Maybe not. The strategy has a 72% backtest win rate over 6 years; my live paper performance has been mixed (we just finished a +$248 week and a flat week). Real-world performance is typically 60–75% of backtest. Anyone promising guaranteed returns is lying. I'm teaching you to build the engine — what you do with it is up to you.

Do I need a $25K account?

For real money, yes — under $25K you hit PDT limits that skip most signals and cripple returns. For learning, no — Alpaca paper accounts are free and unlimited. Build it on paper first. Move to real money only when you've seen 60+ days of live behavior.

Why $497? Why not $97 or $1997?

$97 attracts people who won't finish. $1997 prices out the people I actually want to teach — devs and quants who like building things. $497 sits where the real work meets the real budget.

Is this regulated / are you licensed?

No. I'm not an investment adviser. I'm a builder teaching other builders how to build. The course teaches engineering, not financial advice. The strategies are examples — you choose what to run, how to size it, when to stop.

What if it doesn't work for me?

30-day money-back guarantee. Email me, refund processed. I'd rather you not be the customer who hates me. No fine print.