Professional-grade portfolio risk analytics tool for retail investors, built using Python, Streamlit, and quantitative finance models.
Lack of Accessible Portfolio Risk Analytics for Retail Investors
Retail investors increasingly manage diversified stock portfolios. However, understanding true portfolio risk requires more than observing daily gains and losses.
Professional risk metrics such as Value at Risk (VaR), CVaR, Sharpe Ratio, beta, and correlation matrices provide deeper insight into portfolio exposure. These tools are typically available only through expensive institutional platforms.
Most retail investors:
- Do not measure portfolio volatility properly
- Overestimate diversification
- Ignore tail risk
- Make decisions based on intuition rather than statistical analysis
- Retail investors
- Finance students
- Quant enthusiasts
- Long-term portfolio managers
- Academic researchers
- No lightweight desktop tool integrating risk metrics + simulations
- Limited free tools for Monte Carlo risk modeling
- Lack of interactive visualization for portfolio analytics
- Poor understanding of diversification risk
Retail investors lack:
- Structured risk analytics
- Statistical modeling tools
- Visualization of portfolio exposure
- Scenario-based stress testing
Existing brokerage dashboards focus mainly on:
- P&L tracking
- Basic performance metrics
- No advanced risk decomposition
Build a desktop-based interactive portfolio risk engine that:
- Accepts portfolio holdings
- Fetches historical data using yfinance
- Computes professional-grade risk metrics
- Runs Monte Carlo simulations
- Supports scenario analysis
- Visualizes risk exposure interactively
A Python-based Stock Portfolio Risk Analyzer that combines statistical finance models with interactive dashboards to help investors understand and manage portfolio risk.
Convert historical stock data into actionable risk insights using:
- Quantitative finance formulas
- Monte Carlo simulations
- Matrix algebra
- Modern portfolio theory (Markowitz)
- Multi-Market Support: Unified tracking for both Indian (NSE) and US (NYSE/NASDAQ) stock markets.
- Multi-Currency Toggle: Real-time conversion between USD ($) and INR (₹) for consistent portfolio viewing.
- Smart Portfolio Import:
- Manual ticker entry with auto-complete.
- Bulk Upload: Import holdings via Excel or CSV files.
- Anumati AA Integration: Securely sync portfolio from CDSL/NSDL using Phone and PAN card (Demo Mode).
- Dual Analytical Modes:
- Basic Mode: Simplified health scores and distribution charts for beginners.
- Pro Analytics: Institutional-grade metrics (VaR, CVaR, Sharpe, Beta) for advanced users.
- AI-Powered Insights:
- Quant AI Assistant: Context-aware chatbot (Gemini 2.5 Flash) to analyze your specific risk profile.
- Professional interpretation of complex risk data.
- Advanced Quantitative Engines:
- Monte Carlo simulation (10k paths) for tail-risk estimation.
- Markowitz Mean-Variance Portfolio Optimization.
- Risk Contribution decomposition per asset.
- Historical and Parametric Value at Risk (VaR).
User → Streamlit Frontend → Python Analytics Engine → Risk Models → Visualization → Response
- User inputs portfolio tickers and weights.
- Backend fetches historical adjusted close data using yfinance.
- Data is cleaned and converted to log returns.
- Statistical metrics and covariance matrix are computed.
- Risk models (VaR, CVaR, Monte Carlo, Optimization) are executed.
- Results are visualized using Plotly.
- Interactive dashboard displays analytics.
graph TD
%% User Interaction Layer
subgraph Client_Layer [User Interface - Streamlit]
User([Retail Investor])
Dashboard[Interactive Dashboard]
Inputs[Tickers, Weights & Parameters]
end
%% Processing & Logic Layer
subgraph Logic_Layer [Analytics Engine - Python]
Parser[Input Validator]
subgraph Engine_Components
Calc[Returns & Volatility Calc]
MC_Sim[Monte Carlo Engine]
Opt[Markowitz Portfolio Optimizer]
end
Models[Quant Models: VaR, CVaR, Sharpe]
end
%% Data Acquisition Layer
subgraph Data_Layer [External Data Source]
YF[yfinance API]
DB[(Local Cache / CSV)]
end
%% Visualization & Output Layer
subgraph Output_Layer [Reporting & Viz]
Plotly[Plotly Chart Generator]
Report[Risk Summary Table]
end
%% Data Flow Connections
User --> Inputs
Inputs --> Parser
Parser --> YF
YF --> DB
DB --> Calc
Calc --> MC_Sim
Calc --> Opt
MC_Sim --> Models
Opt --> Models
Models --> Plotly
Models --> Report
Plotly --> Dashboard
Report --> Dashboard
Dashboard --> User
erDiagram
USER ||--o{ PORTFOLIO : owns
PORTFOLIO ||--|{ ASSETS : contains
ASSETS ||--o{ PRICE_HISTORY : tracks
PORTFOLIO ||--|| RISK_REPORT : generates
USER {
string user_id PK
string name
string email
}
PORTFOLIO {
int portfolio_id PK
string portfolio_name
float total_value
float risk_free_rate
}
ASSETS {
string ticker_symbol PK
float weight
float shares_count
float average_buy_price
}
PRICE_HISTORY {
date trading_date PK
string ticker_symbol FK
float adj_close
float daily_return
float volatility
}
RISK_REPORT {
int report_id PK
float value_at_risk_95
float conditional_var
float sharpe_ratio
float max_drawdown
datetime generated_at
}
Entities:
- User Portfolio
- Assets (Ticker, Weight)
- Historical Price Data
- Computed Metrics
- Simulation Results
Relationships:
- One portfolio contains multiple assets.
- Each asset maps to historical price records.
- Risk metrics are computed per portfolio.
Note: MVP version may not require persistent database (in-memory computation).
Historical Stock Price Data
Yahoo Finance via yfinance Python library
- Daily Adjusted Close Prices
- Volume Data
- Market Index Data (for beta calculation)
- Free and accessible
- Decades of historical data
- Supports equities and ETFs
- Sufficient for risk modeling
- Download adjusted close prices
- Align dates across tickers
- Handle missing values
- Compute log returns
- Calculate covariance matrix
- Normalize portfolio weights
Modern Portfolio Theory + Statistical Risk Modeling
Includes:
- Historical Simulation VaR
- Parametric Gaussian VaR
- CVaR (Expected Shortfall)
- Monte Carlo Simulation
- Markowitz Mean-Variance Optimization
- Industry-standard risk measurement techniques
- Computationally efficient
- Interpretable results
- Suitable for retail-level portfolios
- GARCH volatility models
- Student-t distribution modeling
- Black-Litterman model
- Factor models (Fama-French)
- Portfolio volatility
- VaR at 95% and 99%
- Sharpe ratio
- Maximum drawdown
- Risk-adjusted returns
- Streamlit
- Plotly (interactive charts)
- Python
- NumPy
- Pandas
- Monte Carlo simulation
- Statistical risk modeling
- Optimization algorithms
- Optional: SQLite
- MVP: In-memory processing
- Local desktop application
- Optional: Streamlit Cloud / Render
(For MVP, internal Python functions are used instead of REST APIs)
- Fetch Data Module
- Risk Calculation Module
- Monte Carlo Simulation Module
- Optimization Module
(Add Postman / Thunder Client screenshots here if converted to FastAPI)
- Risk model selection
- Mathematical validation
- UI wireframe design
- Data fetching engine
- Return computation
- Covariance matrix
- VaR & Sharpe implementation
- Streamlit dashboard
- Portfolio input UI
- Visualization integration
(Not ML training-based; statistical parameter estimation)
- Estimate mean returns
- Estimate covariance matrix
- Monte Carlo simulation
- Efficient frontier generation
- Optimization constraints
- Streamlit deployment
- Performance optimization
- Documentation completion
- User inputs portfolio.
- Historical data fetched via yfinance.
- Returns and covariance matrix computed.
- Risk metrics calculated.
- Monte Carlo simulation executed.
- Efficient frontier generated.
- Interactive dashboard displays results.
- Live Demo Link: Live Demo
- Demo Video Link: Demo Video
- GitHub Repository: Github Repo
- Model: Colab Model
- PPT: PPT
- Functional risk analytics dashboard
- Monte Carlo simulation engine
- Portfolio optimization module
- Interactive visualization interface
| Member Name | Role | Responsibilities |
|---|---|---|
| Meet Ramatri | Quant Developer | Risk modeling, Monte Carlo simulation |
| Ambuj Vashistha | Backend Engineer | Data processing & optimization |
| Mohit Kourav | Frontend Developer | Streamlit dashboard & visualization |
- Add CVaR optimization
- Add downside risk analysis
- Add portfolio comparison feature
- Add Black-Litterman model
- Add factor-based modeling
- Add real-time streaming data
- Convert into SaaS platform
- Assumes normal distribution in parametric VaR
- Relies on historical data assumptions
- No real-time high-frequency data
- Market regime shifts not modeled
- Improves retail investor risk awareness
- Encourages data-driven decision making
- Demonstrates quantitative finance implementation
- Bridges gap between institutional analytics and retail tools