LIVE · RUNNING TODAY
Featured Project

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.

Stack
Python 3.14 · WebSockets
REST APIs · launchd/cron
Scale
~2,000 lines
State-machine engine
engine_production.py · LIVE
[08:25:00] engine booting · connecting to broker API
[08:25:02] ✓ authenticated · data streams live
[08:25:03] risk manager: daily cap $500 · max 2 trades
[08:25:03] → state: READY
[09:14:00] setup criteria met · signal generated
[09:14:01] ✓ ENTRY: SHORT · qty 1 · bracket placed
[09:14:01] SL set · TP set · R:R 2.7:1
 
[09:38:23] ✓ TP HIT · +$127.50
 
─────────────────────────────
session: 2/2 wins · P&L: +$312.50
state: DONE_FOR_DAY · auto-flatten armed
~2,000
Lines of Code
24/5
Runs Autonomously
< 50ms
Decision Latency
0
Manual Interventions
The Results

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.

Win Rate
54.5%
85 wins · 71 losses · 156 trades
Profit Factor
2.32
gross profit ÷ gross loss
Return / DD
7.7×
total return vs max drawdown
Avg Hold
13.8min
fast in, fast out · bounded risk

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.

Architecture

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.

01 · Data Layer

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.

WebSocket · REST · SignalR
02 · Core Engine

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.

Python 3.14 · State machine pattern
03 · Risk Module

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.

Dedicated guard class
04 · Order Execution

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.

Broker REST API · Bracket orders
05 · Observability

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.

JSON logs · Event replay
06 · Monitoring

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.

Flask · WebSocket · Responsive UI
Production-Grade

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 launchd plist plus a cron job ensures the bot is running by market open every weekday — even if the machine has rebooted overnight.
Performance

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.

$1.6M $1.2M $800k $400k $0 Feb '25 Q2 '25 Q3 '25 Q4 '25 Q1 '26 Feb '26 $1.44M
Total P&L
$1.61M
Trading Days
258
Max Drawdown
$209k
Period
12 months

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.

Why This Matters

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.

/ 01

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.

/ 02

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.

/ 03

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.

Want Work Like This?

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.