Market Data → Strategy → AI Analysis → Decision → Execution → Monitoring
A full-stack algorithmic trading platform for developing strategies, backtesting historical market data, and running automated paper-trading simulations with AI-assisted analysis.
This system brings the core algorithmic trading workflow into one platform:
╔══════════════════════════════════════════════════════════════╗
║ ║
║ 📊 MARKET DATA ║
║ │ ║
║ ▼ ║
║ 🧠 ALGORITHM ║
║ │ ║
║ ▼ ║
║ 🤖 AI ANALYSIS ║
║ │ ║
║ ▼ ║
║ ⚡ TRADING DECISION ║
║ │ ║
║ ▼ ║
║ 💹 ORDER / OUTPUT ║
║ │ ║
║ ▼ ║
║ 📈 MONITORING ║
║ ║
╚══════════════════════════════════════════════════════════════╝
The platform allows users to:
- Create or select trading strategies
- Configure trading rules
- Backtest strategies using historical data
- Analyze performance
- Activate strategies
- Generate automated trading signals
- Simulate order execution
- Monitor positions and trades
- Use AI-assisted market analysis
┌──────────────────┐
│ MARKET DATA │
│ │
│ Historical / Live│
└────────┬─────────┘
│
▼
┌──────────────────┐
│ STRATEGY ENGINE │
│ │
│ Indicators │
│ Conditions │
│ Rules │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ AI ANALYSIS │
│ │
│ Context │
│ Risk │
│ Explanation │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ TRADING DECISION │
│ │
│ BUY / SELL / HOLD│
└────────┬─────────┘
│
▼
┌──────────────────┐
│ TRADING ENGINE │
│ │
│ Risk Validation │
│ Position Sizing │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ PAPER EXECUTION │
│ │
│ Simulated Orders │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ MONITORING │
│ │
│ P&L / Positions │
│ Trades / Logs │
└──────────────────┘
Strategies can be created, configured, tested, and evaluated before activation.
Historical and real-time market data feed the same trading workflow.
AI analysis provides additional context around market conditions and strategy signals.
Risk controls are integrated into the trading engine instead of being treated as an afterthought.
WebSocket market feeds allow the dashboard to reflect trading activity as it happens.
The system simulates execution so strategies can be tested without placing real financial orders.
┌───────────────────────┐
│ FRONTEND │
│ │
│ React + Vite │
│ Tailwind CSS │
│ Dashboard │
│ Strategy Builder │
│ Backtesting │
│ Analytics │
└───────────┬───────────┘
│
REST / WebSocket
│
▼
┌───────────────────────┐
│ BACKEND │
│ │
│ Node.js + Express │
│ JWT Authentication │
│ REST API │
│ WebSocket Server │
└───────────┬───────────┘
│
┌─────────────────────────┼────────────────────────┐
│ │ │
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌─────────────────┐
│ AI SERVICE │ │ TRADING ENGINE │ │ DATABASE │
│ │ │ │ │ │
│ FastAPI │ │ Strategy Rules │ │ MySQL │
│ Python │ │ Signals │ │ │
│ AI Analysis │ │ Risk Controls │ │ Users │
│ ML Hooks │ │ Orders │ │ Strategies │
└──────────────────┘ └──────────────────┘ │ Trades │
│ Positions │
└────────┬────────┘
│
▼
┌──────────────────┐
│ MARKET DATA │
│ │
│ External API │
│ or │
│ Synthetic Data │
└──────────────────┘
| Component | Technology | Responsibility |
|---|---|---|
| 🖥️ Frontend | React + Vite + Tailwind | Trading interface |
| ⚙️ Backend | Node.js + Express + TS | API & orchestration |
| 🤖 AI Service | FastAPI + Python | AI analysis |
| 🧠 Trading Engine | TypeScript worker | Strategy execution |
| 🗄️ Database | MySQL (fallback in-memory) | Persistent data |
| ⚡ Message Bus | Redis (fallback in-memory) | Engine ↔ server events |
| 📡 Market Data | Binance / TwelveData / Synthetic | Price feeds |
| 🏦 Broker Adapter | Paper + Alpaca (extensible) | Order execution |
| 🔐 Authentication | JWT + refresh tokens + 2FA | User authentication |
| ⚡ Real-Time | WebSocket (authenticated) | Live updates |
| 🐳 Deployment | Docker Compose (with engine worker) | Service orchestration |
The trading engine is responsible for converting strategy conditions into simulated trading actions.
Market Tick
│
▼
┌──────────────┐
│ Data Update │
└──────┬───────┘
│
▼
┌──────────────┐
│ Indicators │
└──────┬───────┘
│
▼
┌──────────────┐
│ Strategy │
│ Evaluation │
└──────┬───────┘
│
▼
┌──────────────┐
│ Signal │
│ BUY/SELL/HOLD│
└──────┬───────┘
│
▼
┌──────────────┐
│ Risk Check │
└──────┬───────┘
│
▼
┌──────────────┐
│ Paper Order │
└──────┬───────┘
│
▼
┌──────────────┐
│ Position │
│ Update │
└──────┬───────┘
│
▼
┌──────────────┐
│ Portfolio │
│ Analytics │
└──────────────┘
Before activating a strategy, it can be evaluated against historical market data.
HISTORICAL DATA
│
▼
┌──────────────┐
│ Select Asset │
│ & Timeframe │
└──────┬───────┘
│
▼
┌──────────────┐
│ Configure │
│ Strategy │
└──────┬───────┘
│
▼
┌──────────────┐
│ Run │
│ Backtest │
└──────┬───────┘
│
▼
┌──────────────────────┐
│ Simulated Execution │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Performance Analysis │
└──────────┬───────────┘
│
┌──────┴───────┐
▼ ▼
ACCEPT IMPROVE
│ │
└──────┬───────┘
│
▼
NEXT TEST
The AI service provides additional context around market and strategy behavior.
USER
"Why did my strategy generate a SELL signal?"
│
▼
┌──────────────────┐
│ AI SERVICE │
├──────────────────┤
│ Market Context │
│ Indicators │
│ Strategy Rules │
│ Risk Conditions │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ AI Explanation │
│ │
│ Signal Context │
│ Risk Factors │
│ Market Conditions│
└──────────────────┘
AI is designed as decision support and analysis, rather than blindly controlling the trading engine.
The platform includes several risk-management concepts:
- Stop-loss
- Take-profit
- Position sizing
- Maximum open trades
- Strategy validation
- Trade history
- Activity logs
- Backtesting before activation
- Graceful market-data failure handling
STRATEGY SIGNAL
│
▼
┌──────────────┐
│ RISK CHECK │
└──────┬───────┘
│
┌────────┴────────┐
│ │
PASS FAIL
│ │
▼ ▼
EXECUTE REJECT
ORDER SIGNAL
The platform uses WebSockets to deliver real-time updates between the trading engine and frontend.
MARKET DATA
│
▼
┌─────────────┐
│ Trading │
│ Engine │
└──────┬──────┘
│
WebSocket
│
▼
┌─────────────┐
│ Backend │
└──────┬──────┘
│
WebSocket
│
▼
┌─────────────┐
│ Dashboard │
└─────────────┘
This allows the UI to reflect:
- Live prices
- Strategy signals
- Orders
- Position changes
- Portfolio values
- Trading activity
algorithmic-trading-system/
│
├── database/
│ └── schema.sql
│
├── backend/
│ ├── src/
│ │ ├── routes/ # REST endpoints (auth, strategies, bots, backtest,
│ │ │ # market, marketplace, brokers, alerts, journal, trade)
│ │ ├── services/ # JS bridges to the TS market data layer
│ │ ├── modules/ # TypeScript core: indicators, risk, engine, bus,
│ │ │ # market providers, broker adapters, totp
│ │ ├── data/ # mysql.js + memory.js stores
│ │ ├── config/ # DB/store wiring
│ │ ├── middleware/ # auth (JWT, pending-2FA)
│ │ ├── seed/ # marketplace seeding
│ │ ├── engine/ # standalone engine worker entrypoint
│ │ ├── test/ # vitest suites (indicators, risk, engine)
│ │ └── server.js
│ ├── tsconfig.json
│ └── package.json
│
├── ai-service/
│ ├── main.py
│ ├── models/
│ ├── services/
│ └── requirements.txt
│
├── frontend/
│ ├── src/
│ │ ├── components/ # Layout, CandleChart, StatCard, ProtectedRoute
│ │ ├── pages/ # Dashboard, Market, Strategies, StrategyBuilder,
│ │ │ # Backtest, Bots, Marketplace, Brokers, Alerts,
│ │ │ # Journal, Analytics, AIAssistant, Login, Register
│ │ ├── api/ # client.js (refresh tokens, WS token)
│ │ ├── context/ # AuthContext (2FA + refresh)
│ │ └── hooks/ # useWebSocket
│ └── package.json
│
├── .github/workflows/ci.yml
├── docker-compose.yml
├── .env.example
└── README.md
cd backend
npm install
npm run devPort: 5000
Useful scripts:
npm run typecheck # TypeScript type checking (tsc --noEmit)
npm test # vitest suite (indicators, risk engine, backtest engine)
npm run engine # run the trading engine as an external worker (uses Redis bus)The backend automatically uses an in-memory database when MySQL is unavailable, and an in-memory message bus when Redis is unavailable.
For MySQL, configure the DB_* variables in:
backend/.env
Then import:
database/schema.sql
cd ai-service
python -m venv .venv.venv\Scripts\activatesource .venv/bin/activateInstall dependencies:
pip install -r requirements.txtStart FastAPI:
uvicorn main:app --reload --port 8000Port: 8000
cd frontend
npm install
npm run devPort: 5173
Open:
http://localhost:5173
Run the complete system (MySQL + Redis + backend + engine worker + AI + frontend) using Docker Compose:
docker compose up --buildStop the services:
docker compose downView running services:
docker compose psEach service provides an .env.example.
Create the appropriate environment file:
cp .env.example .envTypical configuration includes:
DATABASE_URL=
JWT_SECRET=
BROKER_ENC_KEY=
REDIS_URL=
ENGINE_EXTERNAL=1
ENGINE_INTERVAL_MS=15000
MARKET_DATA_API_KEY=
MARKET_DATA_API_BASE=
BINANCE_API_BASE=
AI_SERVICE_URL=Never commit production secrets or API keys to the repository.
The system supports three data modes, with automatic fallback.
The default development mode generates synthetic candles so the system can operate without an external market-data provider.
Providers are queried in priority order:
- Binance (
https://api.binance.com) — live candles and 24h tickers for crypto symbols (BTC,ETH,SOL,XRP, …) - TwelveData — stocks, ETFs and forex when
MARKET_DATA_API_KEYis set - Synthetic fallback — used when no provider is available for a symbol
MARKET_DATA_API_KEY=
MARKET_DATA_API_BASE=https://api.twelvedata.com
BINANCE_API_BASE=https://api.binance.comIf an external provider fails, the system falls back to synthetic market data so the platform keeps running.
Bots run in two modes:
- Paper (default) — simulated execution against the built-in paper account
- Live — routed through a connected broker adapter (Alpaca), gated by a connectivity test and a kill-switch (
live_enabled)
Credentials are encrypted at rest (AES-256-GCM) using BROKER_ENC_KEY. A live bot cannot start unless its strategy passes riskEngine.validateForLive() (requires explicit stop-loss and position-sizing rules).
REGISTER
│
▼
DASHBOARD
│
▼
SELECT STRATEGY
│
▼
CONFIGURE RULES
│
▼
BACKTEST
│
▼
ANALYZE RESULTS
│
▼
ACTIVATE
│
▼
PAPER TRADING
│
▼
MONITOR PERFORMANCE
│
▼
AI ANALYSIS
The platform can evaluate strategies using:
| Metric | Purpose |
|---|---|
| Total P&L | Overall profitability |
| Win Rate | Successful trade percentage |
| Profit Factor | Gross profit vs. gross loss |
| Maximum Drawdown | Largest portfolio decline |
| Sharpe Ratio | Risk-adjusted performance |
| Total Trades | Number of executed trades |
| Average Trade | Average trade performance |
| Equity Curve | Portfolio growth |
| Open Positions | Current exposure |
- React frontend
- Express backend
- FastAPI AI service
- JWT authentication
- Database integration
- Synthetic market data
- WebSocket foundation
- Strategy creation
- Strategy activation
- Rule-based signals
- Risk controls
- Advanced strategy builder
- Multi-strategy execution (bot ecosystem)
- Historical data workflow
- Trade simulation
- Performance metrics (Sortino, annualized, expectancy)
- Fees, slippage and shorting simulation
- Parameter optimization (grid search)
- Walk-forward analysis
- Strategy comparison
- AI service
- Market analysis
- AI-assisted explanations
- Context-aware recommendations
- Advanced strategy analysis
- Trading bots (paper + live gating)
- Bot marketplace with one-click install
- Broker connections (Alpaca) with encrypted credentials
- Price alerts
- Trade journal
- Two-factor authentication + refresh tokens
- Redis message bus + external engine worker
- CI/CD workflow
- Monitoring & observability
- Performance optimization
Each major responsibility is separated into its own service.
Strategies can be evaluated using historical data before activation.
Trading activity, orders, positions, and system events are tracked.
External market-data failures do not immediately bring down the platform.
AI analysis is intended to help users understand signals and market conditions.
The architecture separates frontend, backend, AI, trading, and database responsibilities so individual services can evolve independently.
This project is intended for educational, research, and software-development purposes.
Paper trading and backtesting are simulations. Historical performance does not guarantee future results, and simulated execution may differ significantly from live market execution due to factors such as slippage, spreads, latency, liquidity, and market conditions.
AI-generated analysis should not be considered financial advice.
This system does not execute real-money trades by default.