This is a live trading analytics application designed for quantitative traders and researchers. It streams real-time cryptocurrency price data from Binance, stores it locally, calculates statistical trading signals (like spreads and z-scores), and displays everything through an easy-to-use web dashboard.

Think of it as: A mini Bloomberg terminal for crypto pairs that helps you spot trading opportunities in real-time.

1. Real-time Data Streaming: Connects to Binance's live market data feed and receives price updates every millisecond
2. Data Storage: Saves all price ticks to a local database so you can analyze historical patterns
3. Pair Trading Analytics: Compares two cryptocurrencies to find trading opportunities when their prices diverge
4. Visual Dashboard: Shows interactive charts with prices, spreads, and statistical indicators
5. Smart Alerts: Notifies you when trading signals meet your criteria
6. Data Export: Download your analysis results as CSV files

┌─────────────────┐
│  Binance API    │ ← Live market data (BTC, ETH, etc.)
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│ WebSocket       │ ← backend.py connects and listens
│ Ingestion       │
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│ SQLite Database │ ← data_store.py saves every tick
│  (ticks.db)     │
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│ Analytics       │ ← analytics.py calculates signals
│ Engine          │    (hedge ratio, z-score, ADF test)
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│ Streamlit       │ ← app.py displays interactive charts
│ Dashboard       │
└─────────────────┘
         ↓
   Your Browser (localhost:8501)

Step-by-step flow:

1. Ingestion: The app connects to Binance and receives real-time trades (price + quantity)
2. Storage: Each trade is stored in ticks.db with timestamp, symbol, price, and quantity
3. Resampling: Tick data is aggregated into candlesticks (1 second, 1 minute, or 5 minutes)
4. Analytics: For any two symbols (e.g., BTC vs ETH), the app calculates:
   • Hedge Ratio: How much of asset X you need to hedge asset Y
   • Spread: The price difference between the pair
   • Z-Score: How many standard deviations the spread is from its mean (indicates overbought/oversold)
   • ADF Test: Statistical test to check if the spread is mean-reverting
5. Visualization: All results are plotted in real-time on interactive charts
6. Alerts: When z-score crosses your threshold, you get notified

• Python 3.8+ installed on your computer (Download here)
• Internet connection (to stream live data from Binance)
• Command Prompt or Terminal access

Save all project files to a folder, for example: C:\Users\YourName\Desktop\qea

• Press Windows Key + R
• Type cmd and press Enter
• Navigate to your project folder:

cd C:\Users\YourName\Desktop\qea

This keeps your project dependencies isolated:

python -m venv .venv
.venv\Scripts\activate

You'll see (.venv) appear in your command prompt.

pip install -r requirements.txt

This installs all the libraries the project needs (takes 1-2 minutes).

python -m streamlit run app.py

• The app will automatically open at http://localhost:8501
• If it doesn't, manually open your browser and go to that address

• In the dashboard sidebar, click "Start Ingest"
• Wait 10-20 seconds for data to accumulate
• Charts will start updating automatically!

• Streamlit (streamlit>=1.18)
  • What it does: Creates the web dashboard without needing HTML/CSS/JavaScript
  • Why we use it: Fast prototyping, built-in widgets, auto-refresh capabilities

• Pandas (pandas>=1.5)

  • What it does: Manipulates and analyzes tabular data (like Excel on steroids)
  • Why we use it: Resampling ticks to candlesticks, time series operations

• NumPy (numpy>=1.23)

  • What it does: Fast numerical computations and linear algebra
  • Why we use it: Calculating hedge ratios via linear regression

• SQLAlchemy (sqlalchemy>=1.4)

  • What it does: Database toolkit (though we use raw SQLite3 for simplicity)
  • Why we use it: Provides advanced DB features if needed later

• WebSockets (websockets>=11.0)
  • What it does: Maintains persistent connection to Binance for live data
  • Why we use it: Much faster than polling; receives updates instantly

• Plotly (plotly>=5.6)
  • What it does: Creates interactive charts (zoom, pan, hover tooltips)
  • Why we use it: Professional-looking charts with zero effort

• Statsmodels (statsmodels>=0.13)
  • What it does: Advanced statistical tests and models
  • Why we use it: ADF test for stationarity, time series analysis

qea/
│
├── app.py                  # Main Streamlit dashboard (START HERE)
├── backend.py              # WebSocket ingestion from Binance
├── data_store.py           # SQLite database manager
├── analytics.py            # Statistical calculations
├── requirements.txt        # List of Python packages needed
├── README.md              # This file!
├── diagram.drawio         # Architecture diagram (editable)
├── diagram.svg            # Architecture diagram (image)
│
├── ticks.db               # SQLite database (created automatically)
├── check_db.py            # Utility to inspect database contents
└── run_ingest.py          # Standalone ingestion test script

Choose which cryptocurrencies to track (default: BTCUSDT, ETHUSDT, BNBUSDT)

• 1S: 1-second candlesticks (high-frequency view)
• 1T: 1-minute candlesticks (medium-frequency)
• 5T: 5-minute candlesticks (lower-frequency)

Select exactly 2 symbols to analyze their relationship:

• Hedge Ratio (β): From regression Y = α + βX
• Spread: Y - (α + βX) — measures divergence
• Z-Score: (Spread - Mean) / StdDev — normalized signal
• ADF Test: Tests if spread is mean-reverting (p-value < 0.05 = stationary)

Upload your own historical OHLC data to test analytics offline

Set a z-score threshold (e.g., 2.0) to get notified when extreme divergences occur

Download all calculated data (prices, spreads, z-scores) as CSV

• ✅ Zero configuration, single file database
• ✅ Perfect for local prototypes
• ❌ For production: Use TimescaleDB (time-series optimized) or InfluxDB

• ✅ Simple to run (one command)
• ✅ Easy to debug
• ❌ For scale: Separate ingestion (Kafka/Redis) from analytics (microservices)

• ✅ Fast, simple, interpretable
• ✅ Good baseline for hedge ratio
• ❌ For production: Add Kalman Filter (adapts to changing relationships) or Robust Regression (handles outliers)

python run_ingest.py

Should print "Starting ingest for 20s..." and collect data.

python check_db.py

Should show tick counts for each symbol (e.g., BTCUSDT: 1123).

python -m streamlit run app.py

Open browser to http://localhost:8501 and click "Start Ingest".

A single trade event: timestamp, symbol, price, quantity

Open, High, Low, Close prices for a time period (like a candlestick)

The price difference between two assets after adjusting for their correlation

Measures how far the current value is from average (in standard deviations)

• Z > 2: Abnormally high (potential sell signal)
• Z < -2: Abnormally low (potential buy signal)
• Z ≈ 0: Near average (no signal)

A trading strategy that bets prices will return to their average after extreme moves

• app.py: Run this to start the dashboard
• requirements.txt: Install dependencies from here

• backend.py: Modify to add new data sources (e.g., other exchanges)
• analytics.py: Add new calculations (e.g., Kalman filter, Bollinger bands)
• data_store.py: Change database schema or switch to PostgreSQL

pip install -r requirements.txt

Make sure you're in the project folder and virtual environment is activated.

Try:

python -m streamlit run app.py

Instead of just streamlit run app.py.

1. Click "Start Ingest" button in the sidebar
2. Wait 10-20 seconds for data to accumulate
3. Ensure you have internet connection to reach Binance

Close any other Python processes accessing ticks.db:

taskkill /F /IM python.exe

Once you're comfortable with the basics, consider adding:

• Kalman Filter: Dynamic hedge estimation that adapts over time
• Robust Regression: Huber or Theil-Sen for outlier-resistant hedge ratios
• Backtesting Module: Test mean-reversion strategies (z>2 entry, z<0 exit)
• Multi-Exchange Support: Add Coinbase, Kraken data sources
• Message Broker: Use Redis or Kafka to decouple ingestion from analytics
• Advanced Alerts: Email/Telegram notifications, multiple alert rules
• Risk Metrics: VaR, Sharpe ratio, drawdown analysis

• Investopedia: Pairs Trading
• QuantStart: Statistical Arbitrage

• Python for Finance by Yves Hilpisch
• Algorithmic Trading with Python

• Statsmodels Documentation
• Pandas Time Series Guide

This project scaffold and code were generated with assistance from an AI coding assistant (GitHub Copilot using Claude Sonnet 4.5) to speed implementation and produce clear structure.

Prompts used:

• "Create a Streamlit dashboard for real-time crypto pair analytics"
• "Implement Binance WebSocket ingestion with SQLite storage"
• "Add OLS hedge ratio, spread calculation, z-score, and ADF test"
• "Create interactive Plotly charts with controls for timeframe and symbols"
• "Add CSV export and alert functionality"

The AI handled boilerplate code, structure, and integration. Human review ensured correctness, usability, and alignment with quantitative finance best practices.

This prototype is provided as-is for evaluation purposes. Feel free to modify and extend for educational or commercial use.

If you encounter issues:

1. Check the Troubleshooting section above
2. Review the project structure and ensure all files are present
3. Verify Python version (3.8+) and internet connectivity
4. Check ticks.db exists and has data using python check_db.py

Built with ❤️ for quantitative traders and researchers