Hedge: Algorithmic Trading Platform

Product Requirements Document

Version: 1.0
Date: 2026-02-16
Owner: Bob (Chief of Staff)
Stakeholder: Henry Kim

1. Executive Summary

Hedge is a personal algorithmic trading platform that enables systematic strategy development, backtesting, and execution across three accounts with different risk profiles and constraints. The platform replaces intuition-based trading with disciplined, strategy-driven execution.

Core Value Proposition:

Build configurable trading strategies
Backtest strategies against historical data
Execute strategies systematically (day in, day out)

2. Account Structure

Account	Size	Broker	Access	Control Mode	Target
Trading	$3-20K	Alpaca	Full + Options	Automated (approval-based)	Outsized returns
Roth IRA	$92K	TBD	Stocks/ETFs/Limited Options	Guidance only	20-30%/year
401K	$668K	Vanguard	Plan funds only	Guidance only	Beat index

2.1 Trading Account Details

Kept under $25K (subject to PDT: 3 day trades / 5 days)
Options trading active (workaround for PDT via different strikes/expirations)
Phase 1: Human-in-the-loop (no trades without approval)
Phase 2+: Gradual automation based on trust/performance

2.2 Roth IRA Details

Open to leveraged ETFs (TQQQ, UPRO, inverse ETFs)
Momentum up AND down strategies
Limited options: covered calls, cash-secured puts
Henry executes based on recommendations

2.3 401K Details

Vanguard funds only (see Fund List in Second Brain)
30-day holding period per fund
Monthly rebalancing cadence
44 funds available: sectors, bonds, international, target date
Henry executes based on recommendations

3. Functional Requirements

3.1 Strategy Engine

FR-1: Strategy Builder

Define entry/exit conditions using technical indicators
Support multiple asset types: stocks, ETFs, options
Configure position sizing rules
Set risk parameters (stop-loss, take-profit, max position size)
Account-specific strategy assignment

FR-2: Backtesting

Test strategies against historical data (5+ years)
Performance metrics: CAGR, Sharpe, max drawdown, win rate
Transaction cost modeling
Slippage estimation
Compare against benchmarks (SPY, QQQ)

FR-3: Paper Trading

Execute strategies in simulation mode
Real-time market data, simulated fills
Track performance before going live

FR-4: Live Execution (Trading Account)

Connect to Alpaca API
Phase 1: Signal → Alert → Approval → Execute
Phase 2: Configurable auto-execution
Order types: market, limit, stop, bracket
Options order support

FR-5: PDT Tracking

Track day trades in rolling 5-day window
Alert when approaching limit (2/3 used)
Suggest options alternatives to avoid PDT violation

3.2 Portfolio Management

FR-6: Multi-Account Dashboard

View all 3 accounts in single interface
Per-account performance tracking
Aggregate portfolio view

FR-7: Position Tracking

Real-time positions and P&L
Cost basis tracking
Options Greeks display (delta, theta, etc.)

FR-8: Recommendations Engine

Generate daily recommendations for IRA and 401K
Based on active strategies and market conditions
Clear action items: "Sell X, Buy Y, Amount Z"

3.3 Notifications

FR-9: Telegram Integration

Daily summary (positions, P&L, recommendations)
Real-time trade alerts
Approval requests with inline buttons
Execution confirmations

FR-10: Alert Types

Strategy signal triggered
Position limit warnings
PDT limit warnings
Significant P&L moves
Market condition alerts (if configured)

3.4 Data & Analytics

FR-11: Market Data

Real-time quotes (Alpaca included)
Historical OHLCV data for backtesting
Options chains and pricing

FR-12: Performance Analytics

Per-strategy performance attribution
Risk metrics over time
Trade journal with notes
Monthly/quarterly reports

4. Technical Architecture

4.1 Tech Stack

Layer	Technology	Rationale
Frontend	SvelteKit	Consistent with MedSchools.ai
API	SvelteKit API routes	Simple, integrated
Trading Engine	Python (FastAPI)	backtrader, ta-lib, pandas, Alpaca SDK
Database	Supabase (Postgres)	Proven, real-time subscriptions
Cache	Upstash Redis	Real-time price caching
Notifications	Telegram Bot API	Already integrated with OpenClaw
Execution	Alpaca API	Commission-free, great API
Hosting	Vercel (frontend) + Railway (Python)	Cloud-native, scalable
Repo	GitHub Private (widerwings-inc/hedge)	Secure

4.2 System Architecture

┌─────────────────────────────────────────────────────┐
│                 SvelteKit Frontend                   │
│  • Dashboard  • Strategy Builder  • Backtester      │
│  • Portfolio View  • Trade History  • Settings      │
└─────────────────────┬───────────────────────────────┘
                      │ REST API
┌─────────────────────▼───────────────────────────────┐
│              SvelteKit API Routes                    │
│  • /api/strategies  • /api/portfolio                │
│  • /api/backtest    • /api/recommendations          │
└─────────────────────┬───────────────────────────────┘
                      │ Internal API
┌─────────────────────▼───────────────────────────────┐
│           Python Trading Engine (FastAPI)            │
│  • Strategy execution loop                          │
│  • Backtesting engine (backtrader)                  │
│  • Technical indicators (ta-lib)                    │
│  • Alpaca integration                               │
│  • Options pricing                                  │
└───────────┬─────────────────────┬───────────────────┘
            │                     │
┌───────────▼───────────┐ ┌───────▼───────────────────┐
│    Supabase           │ │      External APIs        │
│  • Strategies         │ │  • Alpaca (trading)       │
│  • Trades             │ │  • Market data            │
│  • Portfolios         │ │  • Telegram               │
│  • Performance        │ │                           │
└───────────────────────┘ └───────────────────────────┘

4.3 Database Schema (Core Tables)

accounts - Trading, IRA, 401K configurations
strategies - Strategy definitions and parameters
backtests - Backtest runs and results
positions - Current holdings per account
trades - Trade history
signals - Strategy signals generated
recommendations - Daily recommendations for IRA/401K
notifications - Notification log

5. User Flows

5.1 Trading Account - Approval Flow

Strategy detects signal (e.g., RSI oversold + MACD cross)
System sends Telegram: "📈 BUY Signal: AAPL 100 shares @ $185. [Approve] [Reject]"
Henry taps Approve
System executes via Alpaca
Confirmation: "✅ Executed: BUY 100 AAPL @ $185.12"

5.2 IRA/401K - Guidance Flow

Daily at market close, system runs strategies
Generates recommendations based on signals
Telegram: "📋 Daily Recommendations:\n- IRA: Sell TQQQ, Buy SQQQ (momentum reversal)\n- 401K: Rotate Energy → Health Care"
Henry executes manually in respective brokers
Logs execution in Hedge for tracking

5.3 Backtesting Flow

Henry creates/selects strategy in UI
Sets parameters: date range, initial capital, asset universe
Runs backtest
Reviews results: equity curve, metrics, trade list
Iterates on strategy parameters
When satisfied, activates strategy for paper/live trading

6. Build Phases

Phase 1: Foundation (Weeks 1-3)

Repo setup, project scaffolding
Supabase schema design
Alpaca integration (paper trading)
Basic dashboard (portfolio view)
Telegram bot setup
Single strategy implementation (simple momentum)
Manual trade approval flow

Phase 2: Backtesting (Weeks 4-6)

Historical data pipeline
Backtesting engine integration
Strategy builder UI
Performance metrics & visualization
Multiple strategy support

Phase 3: IRA/401K (Weeks 7-8)

Recommendations engine
401K Vanguard fund mapping
IRA position tracking
Daily recommendation notifications

Phase 4: Options & Polish (Weeks 9-12)

Options trading support
PDT tracking
Advanced order types
Performance analytics dashboard
Live trading activation

7. Success Metrics

Metric	Target
Trading account return	Outperform SPY
IRA return	20-30% annually
401K return	Beat benchmark
Strategy win rate	>55%
System uptime	>99% during market hours
Alert latency	<5 seconds
Backtest speed	<30 seconds for 5-year test

8. Risks & Mitigations

Risk	Mitigation
Strategy underperformance	Paper trading first, gradual capital deployment
API failures	Redundant checks, manual override capability
PDT violation	Automated tracking and warnings
Emotional override	Approval workflow enforces process
Data quality issues	Multiple data source validation

9. Open Questions

IRA broker API access? (Schwab? Fidelity? Need to check)
Options data source for backtesting? (Historical options chains expensive)
Specific indicators/strategies Henry wants to start with?

10. Next Steps

Henry: Create Alpaca account (paper trading)
Bob: Create private repo widerwings-inc/hedge
Bob: Scaffold SvelteKit app + Python service
Bob: Design Supabase schema
Connect Alpaca paper trading
Build first strategy + approval flow

Hedge - Product Requirements Document (PRD)