Note: The live demo runs on a free-tier service. To prevent high costs and long loading times, data loading and AI-powered features are disabled. For full functionality and the best performance, it's recommended to run the application locally.

🖼️ Screenshots

Here's a glimpse of what you can do with AlphaSuite.

Home Page

Backtest Performance Visualization

Analyze the out-of-sample performance of a trained and tuned strategy model.

Summary Metrics & Equity Curve:

Trade Execution Chart:

Detailed Metrics Table:

💡 What Makes AlphaSuite Different?

In a world of numerous trading platforms, AlphaSuite was built to fill a specific gap: bridging the divide between simplistic backtesters and complex, institutional-grade systems. Its core philosophy is that modern trading strategies should be adaptive and data-driven from the ground up.

Unlike many platforms where machine learning is an optional add-on, AlphaSuite is ML-native. Its entire workflow is designed to be driven by ML models, reflecting the shift in quantitative finance away from static rules and toward dynamic strategies that learn from the market.

Key differentiators include:

• End-to-End ML-Centric Workflow: Strategies are built around ML features, not just enhanced by them. The model's output is the signal.
• Built-in Professional Risk Management: The framework's core trading logic enforces disciplined, non-negotiable risk management. Position sizing is systematically calculated based on volatility (e.g., ATR) and a predefined risk-per-trade, a feature often missing from traditional backtesters. This enforces capital preservation by design.
• Enables Strategy-Driven Context Awareness: While not a built-in feature, the framework provides the tools and hooks for strategies to become regime-aware. Developers can easily incorporate market context (like volatility regimes or trend strength) into their features, allowing models to learn when and why a setup is effective.
• Focus on Robust Validation: With tools like walk-forward analysis and portfolio-level backtesting, AlphaSuite emphasizes proving a strategy's edge on unseen data, avoiding the common pitfalls of overfitting.

In short, AlphaSuite isn’t just about asking “would this have made money?”—it’s about building strategies that understand when to trade, how much to risk, and why they have an edge.

📖 Articles & Case Studies

Check out these articles to see how AlphaSuite can be used to develop and test sophisticated trading strategies from scratch:

• Stop Paying for Stock Screeners. Build Your Own for Free with Python: A comprehensive guide on using AlphaSuite's modular market scanner to build custom screens for any market, moving beyond the limitations of commercial tools.
• From Backtest to Battle-Ready: A Guide to Preparing a Trading Strategy with AlphaSuite: A practical, step-by-step walkthrough for taking a strategy from concept to live-trading readiness using our open-source quant engine.
• We Backtested a Viral Trading Strategy. The Results Will Teach You a Lesson.: An investigation into a popular trading strategy, highlighting critical lessons on overfitting, data leakage, and the importance of robust backtesting. Also available as a video narration.
• I Was Paralyzed by Uncertainty, So I Built My Own Quant Engine: The story behind AlphaSuite's creation and its mission to empower data-driven investors. Also available as a video narration.
• From Chaos Theory to a Profitable Trading Strategy: A step-by-step guide on building a rule-based strategy using concepts from chaos theory.
• Supercharging a Machine Learning Strategy with Lorenz Features: Demonstrates how to enhance an ML-based strategy with custom features and optimize it using walk-forward analysis.
• The Institutional Edge: How We Boosted a Strategy’s Return with Volume Profile: A deep dive into using Volume Profile to enhance a classic trend-following strategy, demonstrating a significant performance boost.
• Trading with Less Surprise: Using Shannon Entropy to Improve a Breakout Strategy: Demonstrates how a concept from information theory can dramatically improve a classic trend-following strategy.
• The Feature Engineering Treadmill: Why One “Magic” Feature Isn’t Enough: Explores how to evolve a promising idea into a more robust, multi-asset system.
• Your Trading Strategy Has No Context and That’s the Problem: Explores the importance of market regime features, compare several methods we’ve tested using AlphaSuite.
• Beyond the Almanac: Supercharging Trading Strategies with On-Demand Seasonality Analysis: Introudces AlphaSuite's new on-demand seasonality analysis feature that can analyze seasonality on the fly for a specific ticker.
• Algo Trading Series, Part 1: The Resolution — Stop Guessing, Start Measuring: Why your New Year’s resolution shouldn’t be “trade better” — it should be “trade differently.”
• Algo Trading Series, Part 2: The AI Toolkit — Architecture of a Quant Engine: How machines really learn to trade, and why a robust testing framework is non-negotiable.
• Algo Trading Series, Part 3: The Concept — Hunting for Liquidity: Why “Smart Money” hunts stops, and how to write Python code to find them.
• Algo Trading Series, Part 4: Codifying the Edge — When Textbooks Meet Reality: How to build a ML strategy based on the “Smart Money Concepts.”
• Algo Trading Series, Part 5: The Optimization — From Theory to Production: How to evolve the structure_liquidity strategy into an adaptive, Machine Learning-driven sniper.
• Algo Trading Series, Part 6: The Litmus Test — If You Feed It Garbage, Does It Still Eat?: We stress-test the strategy with Noise Injection to ensure the edge is real and not just overfitting.

🛠️ Tech Stack

• Backend: Python
• Web Framework: Streamlit
• Backtesting Engine: pybroker
• Data Analysis: Pandas, NumPy, SciPy
• Financial Data: yfinance, TA-Lib
• Database: PostgreSQL with SQLAlchemy
• AI/LLM: LangChain, Google Gemini, Ollama

📂 Project Structure

The project is organized into several key directories:

• core/: Contains the core application logic, including database setup (db.py), model definitions (model.py), and logging configuration.
• pages/: Each file in this directory corresponds to a page in the Streamlit web UI.
• pybroker_trainer/: Holds the machine learning pipeline for training and tuning trading models with pybroker.
• strategies/: Contains the definitions for different trading strategies. New strategies can be added here.
• scanners/: Contains the definitions for custom market scanners. New scanners can be added here.
• tools/: Includes various utility modules for tasks like financial calculations, data scanning, and interacting with the yfinance API.
• Home.py: The main entry point for the Streamlit application.
• download_data.py: The command-line interface for all data management tasks.
• quant_engine.py: The core quantitative engine fo