End-to-end, low-latency trading stack that takes a researched strategy from Python backtests to live market execution.
Autoboughts is a production‑style systematic trading infrastructure that I designed to:
- Ingest live tick data from broker WebSockets (Python).
- Convert ticks into real‑time OHLC structures and apply proprietary logic.
- Generate deterministic BUY/SELL signals in a low‑latency Rust core (implemented with AI assistance, but architected and integrated by me).
- Route orders into the live market via broker APIs from a Python execution layer.
- Log executions and run live portfolio/risk checks.
The strategy logic itself is proprietary; this project is about the engineering and architecture required for a systematic trader to run strategies live.
Through structured backtesting and market research, I developed:
- Candlestick pattern-based signal detection
- Technical indicator confirmation layers
- Real-time execution-time validation
- Deterministic exit logic
- Latency-aware signal generation pipeline
Focus areas:
- Signal determinism
- Minimal execution delay
- Modular architecture
- Clear separation of research and execution layers
- Broker WebSocket → Tick ingestion (Python)
- Python Pub/Sub → ZeroMQ pipeline
- Rust Strategy Engine → OHLC + Signal logic
- Rust Signal Stream → Published to execution layer
- Python Execution Layer → Broker API order placement
- Order logging + live portfolio validation
The strategy engine is written in Rust for performance, built with help from AI tools but fully designed and integrated by me:
- Subscribes to the ZeroMQ tick stream and builds OHLC candles in real time.
- Applies the proprietary strategy logic and publishes a clean, deterministic signal stream.
- Keeps state and processing latency predictable so that Python execution can stay simple and robust.
- Python
- FastAPI
- Async WebSockets
- Broker API integration
- ZeroMQ (Pub/Sub model)
- Socket pipelining
- Rust
- Tick-level processing
- Real-time OHLC aggregation
- Signal stream publishing
- Low-latency design
- Non-blocking architecture
- Separation of concerns
- Microservice-style modularity
- Event‑driven, non‑blocking design from tick ingestion to order placement.
- Rust core keeps the heavy tick/OHLC/signal work off the Python layer.
- Python focuses on clean order routing, logging and risk checks, which is what matters for a systematic trader running live capital.
- Tick-by-tick processing
- Real-time OHLC conversion
- Pattern-based signal generation
- Pub/Sub signal architecture
- Live broker execution
- Order logging & portfolio check
- Modular quant engine design
The trading strategy logic, signal generation code, and execution implementation are proprietary and not publicly available.
This repository exists to demonstrate:
- Quantitative system design capability
- Low-latency infrastructure engineering
- Systematic trading architecture thinking
- Multi-language integration (Rust + Python)
Code may be shared in a professional discussion setting.
- Systematic trading mindset
- Start from researched, backtested ideas and design the full path to live execution.
- Think in terms of regimes, risk, execution quality and robustness, not single trades.
- Python for trading systems
- Tick ingestion, OHLC construction, execution/risk services, logging and monitoring.
- Async/WebSocket experience and broker API integration.
- Architecture & performance
- Designed the full data → signal → execution pipeline and chose Rust where low latency matters.
- Used AI productively to accelerate Rust implementation while owning the overall architecture and trading logic.
Built independently as a systematic trading infrastructure project
Focused on production-grade quant system design.