Nights & Weekends · Independent Venture

Autonomous Trading Platform

A side project in systematic trading: teaching a Python system to read the market and act on rules instead of impulse, one paper trade at a time.

Python Alpaca API VWAP Strategy Risk Management Paper Trading
Worth saying plainly This runs entirely on Alpaca's paper trading environment: real market data, simulated money. It's a personal engineering project, not investment advice, and it isn't trading real capital.
Why This Exists

Curiosity, pointed at the market

The day job is spent governing enterprise technology portfolios: setting the rules, reading the dashboards, trusting the process to be more disciplined than any one person's gut feeling. This project asks whether the same discipline holds up somewhere with much faster, much less forgiving feedback than a quarterly budget review.

It started as a question more than a plan: could a set of clear, written rules make better trading decisions than the emotions that usually drive them? Fear, greed, and boredom don't touch a Python script the way they touch a person watching a ticker. Building the system was a way to find out, one paper trade at a time, in a domain that has nothing to do with the day job and everything to do with the same instincts for signal, risk, and discipline.

What It Does

A disciplined day trader, minus the discipline problem

At its core, the platform watches a small, hand-picked list of stocks for a specific pattern: a price drifting far enough from its running volume-weighted average to suggest it's likely to snap back. That's the VWAP mean-reversion strategy at the center of the current build, connected to a live Alpaca paper trading account through the alpaca-py SDK.

The system doesn't just find the signal, it manages the position around it: sizing the trade, watching the risk, and automatically flattening everything at the end of the day so nothing is left exposed to overnight news. The whole thing was built in Visual Studio with Claude Code doing a lot of the heavy lifting on the implementation, while the strategy logic and risk rules stayed a very deliberate, human decision.

Mockup of the Signal Desk dashboard showing account equity, index tickers, and P&L by trading process for the paper-trading account.
Illustrative mockup. Modeled on the real dashboard — account balances, index tickers, and P&L by trading process — redrawn here rather than captured live.
How It's Built

The pipeline, at a glance

Kept simple on purpose: data comes in, a decision gets made, a trade goes out, and the loop confirms what actually happened.

Market Data Alpaca IEX feed watchlist prices Strategy Engine VWAP mean reversion signal logic Risk & Execution position sizing end-of-day flattening Broker (Paper) Alpaca paper account simulated fills prices signal order fill confirmation
Market data continuously feeds the strategy engine; a qualifying signal moves through risk and execution to the broker, which confirms each simulated fill back so the position book stays accurate.
Open Threads

What's next on the workbench

Still evolving, still being tinkered with. A few threads currently open.

Better market data

Weighing Alpaca's free IEX feed against the paid SIP consolidated tape, which would give the strategy a fuller, more accurate picture of the market instead of one exchange's slice of it.

A second broker

Looking into connecting a Schwab account through its OAuth 2.0 API and the schwab-py library, mostly to see what it takes to make the execution layer broker-agnostic.

Smarter alerts

Exploring lightweight ways to get a heads-up when the broader market makes a big move, without needing an always-on background process watching the ticker.

Want to compare notes?

Always happy to talk Python, trading systems, or where automation should and shouldn't be trusted with a decision.