Autonomous Trading Platform
Built solo, backend-first, with most of the effort in the research and risk engine. One engine runs the same strategy logic across backtesting, paper trading, and live execution; live trading is gated behind several independent safety checks rather than a single on/off flag.
System Overview
The backend is layered strictly, and dependencies only ever point inward:
A Signal becomes an OrderIntent, which becomes a BrokerOrder/Fill, which updates Positions and rolls up into Reports — and that same contract chain is used whether the run is a historical backtest, a paper trading cycle, or (once enabled) live. One engine, one set of data shapes, three execution contexts.
Requests flow through a fixed middleware stack: RequestID → Logging → JWT → Deprecation.
The one non-negotiable: NO_LIVE_TRADING is enforced at runtime, not just in config. Live order submission requires clearing several independent gates (below) — no single flag flip puts real capital at risk.
Key Features
Safety
- A DB-persisted kill switch that survives process restarts and crashes — killing trading doesn't depend on an in-memory flag.
- Layered enablement gates: a build-time gate, a config gate, and a runtime human-confirmed activation step, plus a broker account allowlist and hard caps/throttles on order size and rate.
- Strict environment isolation between paper and live, with
NO_LIVE_TRADING enforced at runtime as the final backstop.
- A reconciliation model that freezes trading and requires human acknowledgment on any mismatch between internal state and the broker's.
Research / Strategy / Experiment Systems
- A strategy registry (moving average crossover, momentum, mean reversion, factor-based, and composite-rule strategies, plus test/fixture strategies) with warmup/validator/generation metadata per entry.
- Reproducible experiment artifacts — every run produces a manifest with dataset lineage hashes so results can be traced back and replayed exactly.
- A six-stage validation pipeline: survivorship validation, walk-forward validation, regime-concentration checks, overfitting analysis, deterministic stress testing (volatility spikes, return shocks, drawdown amplification, trend reversal, liquidity collapse), and parameter sensitivity.
Governance & Capital Allocation
- A five-rung progressive drawdown governance ladder (NORMAL → WARNING → PROBATION → SUSPENDED → BREACHED) with hysteresis and cooldowns so the system doesn't flap in and out of restrictions on noisy data.
- Portfolio-level and sector concentration risk limits enforced pre-trade, plus strategy health monitoring that can auto-demote a strategy or auto-promote it between research/paper tiers based on live performance — promotion to live trading remains a manual, admin-gated step.
- Multi-strategy capital allocation: risk parity / risk budgeting allocation, a Black-Litterman research service for view-based allocation, a pure-numpy mean-variance optimizer (projected gradient descent with KKT bisection), and signal netting across strategies (conservative, dominant, proportional, plus allocation- and confidence-weighted variants) to avoid strategies fighting each other for the same exposure.
Portfolio Intelligence
- Market regime classification across five dimensions (trend, volatility, liquidity, mean-reversion, risk) with regime-conditioned performance analysis — so a strategy's results are broken down by the market conditions they were earned in, not just averaged.
- Correlation/covariance monitoring with cluster detection, surfacing when strategies are quietly taking correlated bets rather than diversifying.
Data & Storage Layer
- Postgres system-of-record for orders, fills, positions, and runtime state, alongside versioned Parquet datasets for market bars and features.
- An immutable event log covering every order and lifecycle transition, giving a full audit trail of what the system did and when.
- Time-aware universe governance: versioned universe snapshots, survivorship-bias elimination, and explicit handling of symbol lifecycle events (delisting, merger, rename) so historical backtests never "see" a universe that didn't exist at the time.
Backtesting & Simulation Engine
- Deterministic backtest engine that shares its execution contracts with paper/live trading — the same
Signal → OrderIntent → Fill → Position pipeline runs historically and live, so backtest results reflect how the system actually executes.
- Fill and cost modeling with a calibrated slippage model, plus dividend- and split-aware simulation so historical P&L accounts for corporate actions correctly.
Testing Suite
- Unit and service tests run against SQLite in-memory; integration tests run against a real Postgres instance.
- Marker-based test segmentation (
integration, external, alpaca, smoke, paper_runtime) so a fast unit-only pass can run separately from slower external/broker-dependent tests.
Observability
- OpenTelemetry instrumentation across the runtime, feeding into Grafana for metrics and traces.
Tech Stack
Backend
| Layer | Tools |
|---|
| Language | Python 3.11 |
| API | FastAPI, Uvicorn |
| ORM / DB | SQLAlchemy, PostgreSQL 16, Alembic (migrations) |
| Data / Storage | PyArrow (Parquet), DuckDB |
| Market data / Broker | alpaca-py, exchange_calendars |
| Optimization | cvxpy, NumPy, SciPy |
| Orchestration | Apache Airflow |
| Observability | OpenTelemetry, Grafana |
| CLI | Typer, Rich |
| Testing | pytest, pytest-asyncio, pytest-cov |
Frontend
| Layer | Tools |
|---|
| Framework | React 19, Vite, TypeScript (strict) |
| Routing / Data | TanStack Router, TanStack Query, Axios |
| State | Zustand |
| Forms | React Hook Form, Zod |
| UI | Tailwind CSS, shadcn/ui (Radix primitives), Framer Motion |
| Data display | Recharts, Lightweight Charts, TanStack Table |
| Testing | Vitest, Testing Library, Playwright |
Status
The backend is deep and functionally real: the contracts, storage, service, and API layers described above are implemented and tested, not sketched out. The frontend — Dashboard, Portfolio, Strategy Lab, Controls, Settings, and Experiment Lab — is wired to real backend endpoints, not mock data, but it was originally built around a generic SaaS-style app shell rather than the platform's actual domain model (governance, safety gates, the research pipeline). It's functional, not fake, but due for a restructuring pass rather than a wiring pass. The system currently runs in paper trading only — NO_LIVE_TRADING is enforced at runtime, so no real capital is at risk.
What's Next
A full 2-year backtest validates the platform end-to-end, but that's still a controlled environment. The path from here to real deployment:
- Performance optimization — the monthly research pipeline (candidate generation, walk-forward, Monte Carlo validation) is the current bottleneck; profiling and speeding it up comes first, since faster iteration speeds up everything downstream.
- Cloud deployment — move off a local machine onto the containerized services already in place (Postgres, Airflow, observability stack), enabling continuous scheduled operation instead of manual local runs.
- Frontend restructuring — rebuild the UI around the platform's real domain model instead of the generic app shell it started from.
- Paper trading — run live against real-time market data to validate that real-world timing, latency, and execution assumptions hold up the way the backtest assumed.
- Live trading — after a sustained, monitored paper-trading track record, move to live capital under the existing safety architecture (layered enablement gates, persistent kill switch, drawdown governance in full enforcement mode rather than backtest's
warn_only setting).
Quickstart
This is a multi-service system — the full pipeline (Postgres, Airflow, ingestion, research, paper trading) involves several CLI steps, config decisions, and a specific run order, documented in docs/operations/runbooks/ and docs/backend/cli/. What's below just gets the code installed and the test suite passing locally — the fastest way to confirm the codebase is real and working, without needing Docker or a database running.
# Clone
git clone https://github.com/TristanODonnell/Autonomous-Trading-Platform.git
cd Autonomous-Trading-Platform
# Backend — Python 3.11, virtual environment
python -m venv .venv
.\.venv\Scripts\activate # Windows
# source .venv/bin/activate # macOS/Linux
pip install -r requirements.txt
pip install -r requirements-dev.txt
pip install -e .
# Run the test suite — SQLite in-memory, no Postgres/Docker required
python -m pytest
# Frontend
cd frontend
npm install
npm run dev
For the full local stack (Postgres, Airflow, observability) and the CLI-driven ingestion → research → paper-trading sequence, see docs/operations/runbooks/ and docs/backend/cli/.
License
All rights reserved. This code is shared publicly for review purposes; no license is granted to copy, modify, or redistribute it.
