Live, production-grade software.
A close look at a real project running in production right now — betting real money on a live prop firm account.
The Liquidity Bot.
A production-grade algorithmic futures trading system, currently running on a live prop firm evaluation account. Built from scratch in Python, hardened through months of real-market iteration.
This is what "production-grade" actually looks like — not a weekend project, not a backtest that worked once. Code you can bet real money on.
A year of backtested market data.
Before a single dollar of real money went through this system, the core logic was validated across a full year of historical MES futures data — Feb 2025 through Feb 2026, covering every regime the market threw at it.
54.5% win rate at a profit factor of 2.32 means winning trades average almost twice the dollar value of losers — the system is designed for asymmetric payoffs, not high accuracy. And the 7.7× return-to-drawdown ratio is the number that matters most: it means for every dollar the account drew down at its worst, the system generated nearly eight in total return.
There's a meaningful long/short asymmetry: short trades win 58.4% of the time vs 49.3% on longs, and produce nearly 2× the P&L. That's because markets fall faster than they climb — a behavior the engine's risk model is built around.
Strategy specifics are kept private — but the results, architecture, and engineering decisions behind the system are openly shared below.
Built on a clean systems architecture.
No monolithic script. The engine is structured as isolated modules, each with one clear responsibility — so failures are traceable and fixes don't cascade.
Real-time market feeds
WebSocket connections pull live price data direct from the broker, buffered and normalized before it reaches the engine. Reconnect logic built in for dropped connections.
State-machine control flow
Every possible engine state is explicitly defined. Every transition is logged. No ambiguous "what is the bot doing right now?" — always answerable with a single state field.
Isolated risk manager
Daily loss caps, per-trade limits, and max trade counts are enforced by a dedicated class — not sprinkled throughout the code where bugs could bypass them.
Bracket orders, atomic
Every entry ships with stop-loss and take-profit as a single bracket order. If the entry fills, the exits are already armed — no window where a position sits unprotected.
Structured JSON logs
Every state transition, order, fill, and error is logged as structured JSON. When something unexpected happens, the exact sequence of events can be replayed after the fact.
Mobile dashboard
A Flask + WebSocket app pushes live state to a phone-friendly UI: start/stop controls, equity curve, current state, last trade. Check on the system from anywhere without a laptop.
The boring parts that matter most.
What separates a working demo from software you can trust overnight: all the unglamorous details most tutorials skip.
- Reconnection logic. WebSocket drops happen. The bot detects them, backs off with exponential retry, and resumes exactly where it left off — without losing track of open positions.
- Auto-flatten before close. Holding futures overnight isn't allowed on prop firm evaluations. A hard cutoff guarantees all positions close before the 3 PM CT bell — no exceptions, no surprises.
- Structured logging, every event. State transitions, orders, fills, errors — all logged as JSON. When something weird happens, I can replay the exact sequence of decisions that led to it.
- Risk manager as a separate module. Daily loss limits, per-trade limits, and max trade count are enforced by a dedicated class — not sprinkled throughout the code where they can be accidentally bypassed.
- Mobile dashboard. A Flask + WebSocket app pushes live state to a phone-friendly UI: start/stop buttons, equity curve, current state, last trade. I can check in during errands without needing a laptop.
- Auto-start on boot. A
launchdplist plus a cron job ensures the bot is running by market open every weekday — even if the machine has rebooted overnight.
The curve that matters.
Equity growth across 156 trades over 258 trading days. Risk-scaled position sizing means growth compounds — the slow build in 2025 pays off as the account gets larger.
Backtest results using historical MES futures data (Feb 2025 – Feb 2026) with risk-scaled position sizing. Past performance, whether simulated or live, is not a guarantee of future returns. Trading futures carries substantial risk and is not suitable for all investors.
The Liquidity Bot is a trading system — but the craft is universal.
The same engineering principles that keep a trading bot running reliably through live market volatility are what I bring to every client project. State machines. Error handling. Structured logs. Auto-recovery. Dashboards you can check from your phone.
Reliability over novelty
I build with tools that'll still work in five years — not whatever's trending this week. Your business runs on boring, battle-tested software for a reason.
Observability by default
Every project I ship includes structured logging and a way to see what's happening in real time. If something breaks, you know immediately — and so do I.
Designed to survive
APIs go down. Servers reboot. Power flickers. The software I write assumes these things will happen — and recovers gracefully when they do.
Let's build you
something just as durable.
Whether it's an AI tool, automation, dashboard, or web app — the same production-grade engineering applies. Tell me what you're trying to solve.