three years of paper trading, finally real money #
started learning algo trading april 2020 during COVID lockdown. i was 16, bored af at home, discovered r/algotrading and fell into the rabbit hole
spent three years building strategies in Python. paper trading. backtesting on two years of data. reading every post on r/options and r/quant. building custom metrics in Plotly because traditional charts felt useless
today, march 15th 2023, my first algo went live with real money
i’m 19. my parents died december 31st 2022 (new year’s eve, car crash). inherited $2M. put $400k into Interactive Brokers. lost $180k in the first two months learning with real money
yeah. $180k gone. February was brutal
but i figured some things out. joined NexusFi in january after my parents died because i needed support from people who actually trade. that community is legit - Big Mike runs a tight ship, zero tolerance for BS artists trying to sell courses
today’s algo is basic. SPX credit spreads. nothing fancy. but it’s profitable in backtest and i’m done waiting
the strategy (simple on purpose) #
selling credit spreads on SPX because:
- European style (no early assignment risk)
- cash settled (no stock delivery headaches)
- liquid af (tight spreads, instant fills)
- tax advantaged (60/40 treatment, hell yeah)
the rules i coded:
# entry logic
- sell when IV percentile > 40 (elevated vol)
- target 5-7 DTE (days to expiration)
- delta 0.20-0.25 on short strike (80% prob OTM)
- max 5 concurrent positions
- $10 wide spreads ($1000 max loss per)
# exit logic
- close at 50% profit OR
- close at 2 DTE (don't hold to expiration)
- emergency stop if position hits -200% (spread doubles against me)
backtested this on 2 years SPX data (2021-2022). sharpe ratio 1.9, win rate 72%, max drawdown 18%
solid. not amazing. but repeatable
the code (backtrader + ib_insync) #
using backtrader for backtesting, ib_insync for live execution
here’s the core (simplified, real version is 400 lines with error handling):
import backtrader as bt
from ib_insync import *
class SPXCreditSpreadStrategy(bt.Strategy):
params = (
('dte_entry', 7),
('dte_exit', 2),
('delta_short', 0.25),
('profit_target', 0.50),
('max_positions', 5),
('spread_width', 10),
('iv_min', 40),
)
def __init__(self):
self.positions = []
self.ib = IB()
self.ib.connect('127.0.0.1', 4001, clientId=1)
def next(self):
# position limit check
if len(self.positions) >= self.p.max_positions:
return
# get IV percentile
iv_rank = self.get_iv_rank('SPX')
if iv_rank < self.p.iv_min:
return # not elevated enough
# find option chain for target DTE
chains = self.get_spx_chains(dte=self.p.dte_entry)
# find short strike at target delta
short_call = self.find_strike_by_delta(
chains,
delta=self.p.delta_short,
option_type='C'
)
# long call 10 points higher (protection)
long_call = short_call + self.p.spread_width
# calculate premium collected
credit = self.get_spread_price(short_call, long_call)
# create spread order
self.sell_vertical_spread(
short_strike=short_call,
long_strike=long_call,
credit=credit
)
def manage_positions(self):
"""check exit conditions on open positions"""
for pos in self.positions:
days_left = self.get_dte(pos.expiration)
pnl_pct = pos.unrealized_pnl / pos.initial_credit
# profit target hit
if pnl_pct >= self.p.profit_target:
self.close_position(pos)
# approaching expiration
elif days_left <= self.p.dte_exit:
self.close_position(pos)
# emergency stop (spread doubled against us)
elif pnl_pct <= -2.0:
self.close_position(pos)
real implementation has way more:
- retry logic for failed orders
- slippage tracking
- Greeks monitoring
- position sizing based on portfolio heat
- alerts when IV rank spikes
but that’s the core logic
today’s first trade #
opened one position this morning at 9:45 AM PST:
SPX Call Credit Spread:
- sold 4300 call @ $2.20
- bought 4310 call @ $1.35
- net credit: $0.85 ($85 per spread)
- max loss: $915 (10 point width - credit)
- expiration: march 22 (7 DTE)
- probability OTM: 78% (per IB probability calculator)
risking $915 to make $85 sounds terrible. but do it 20 times and win 15 of them and you’re profitable
that’s the math. high win rate, small gains, controlled losses
what i learned in 60 seconds of live trading #
whoa backtesting is NOT the same as live
slippage is real
- backtested at $0.90 credit
- actually filled at $0.85 ($5 worse per contract)
- on a $915 max loss position, $5 matters
fills take time
- paper trading = instant fills
- real money = waited 90 seconds staring at DOM
- almost cancelled because i got nervous
emotions hit different
- hands were shaking hitting submit
- $915 max loss feels way bigger than it looked in backtest
- had to walk away from computer for 10 minutes after
this is $400k of my inheritance. $180k already gone. every trade matters
february’s $180k lesson #
lost $180k in february learning what NOT to do:
mistake 1: overleveraging
- opened 15 positions at once (way too many)
- portfolio heat hit 40% (insane)
- when market moved against me, everything correlated
mistake 2: fighting the trend
- kept selling call spreads in a ripping market
- “it HAS to pull back” (narrator: it didn’t)
- got assigned on 3 positions, blew through max loss
mistake 3: no stop loss discipline
- let losing positions run to expiration hoping for miracle
- “theta will save me” (theta did not save me)
- several positions went from -100% to -250%
mistake 4: ignoring IV rank
- sold premium when IV was at 15th percentile
- collected $40 per spread risking $960
- even with 70% win rate, expectancy was negative
those four mistakes cost $180k in 8 weeks
incredibly painful
but i learned. that’s worth something. maybe
what changed #
talked to traders on NexusFi who’ve been through this
key advice that stuck:
- max 5 positions at once (portfolio heat control)
- only sell when IV rank > 40 (actually elevated)
- close at 50% profit (don’t get greedy)
- use stops (emergency exit if spread doubles)
- position size = 2.5% account risk max
implemented all of it in the algo
march 1-15: paper trading with new rules. 12 trades, 10 winners, sharpe 2.1
good enough. went live today
the reality check #
i’m 19 years old. my parents died 10 weeks ago. i’m trading $400k of inheritance money after losing $180k learning
some days i’m numb. some days i cry random. tonight i’ll probably stare at this one open position for 3 hours unable to sleep
this is the reality of algorithmic trading when you’re young and your parents just died and you’re trying to make this work
not the YouTube version. the real version
what’s next #
gonna run this strategy for 90 days and track everything in custom Plotly dashboards:
metrics i’m tracking:
- actual fills vs theoretical backtest
- slippage per trade
- win rate (target: 70%+)
- sharpe ratio (target: 1.5+)
- max drawdown (limit: 15%)
- IV rank at entry (verify > 40)
- days held per position
- profit per day-held
if sharpe stays above 1.5 and drawdown under 15% after 90 days, i’ll scale up to 2 contracts per spread
if it fails, back to paper trading and figure out what’s broken
why i’m writing this #
accountability
it’s easy to lie to yourself when you’re alone in a San Diego apartment trading inheritance money and your parents are dead
writing this publicly on the internet keeps me honest
document the wins, the losses, the $180k tuition, the mistakes, the learning
maybe it helps someone else who’s thinking about algo trading. maybe it just helps me stay disciplined
either way, here we go
first algo live. one position open. SPX 4300/4310 call spread. march 22 expiration
let’s see what happens
-AK