Nija

NIJA Performance Dashboard

Overview

The NIJA Performance Dashboard provides investor-grade performance tracking and reporting. This is capital-raising infrastructure designed to provide institutional-quality metrics and reports.

Features

Core Metrics

  1. Daily NAV Tracking
    • Net Asset Value calculation
    • Total equity tracking
    • Cash and positions breakdown
  2. Equity Curves
    • Historical equity performance
    • Time-series equity data
    • Customizable date ranges
  3. Drawdown Curves
    • Real-time drawdown tracking
    • Maximum drawdown identification
    • Drawdown recovery periods
  4. Sharpe Ratio Tracking
    • Daily Sharpe ratio calculation
    • Sortino ratio (downside-only risk)
    • Risk-adjusted returns
  5. Monthly Performance Reports
    • Month-by-month breakdown
    • Return analysis
    • Risk metrics per month

Components

1. Performance Metrics Calculator (bot/performance_metrics.py)

Core calculation engine for all performance metrics.

Key Classes:

Metrics Calculated:

2. Performance Dashboard (bot/performance_dashboard.py)

High-level dashboard interface for investor reporting.

Key Features:

3. Dashboard API (bot/dashboard_api.py)

Flask API endpoints for accessing dashboard data.

Endpoints:

4. Database Models (database/models.py)

Extended with performance tracking tables:

Usage

Basic Setup

from bot.performance_dashboard import get_performance_dashboard

# Initialize dashboard
dashboard = get_performance_dashboard(
    initial_capital=10000.0,
    user_id="user123"
)

Recording Performance Data

# Update snapshot with current portfolio state
dashboard.update_snapshot(
    cash=8000.0,
    positions_value=4500.0,
    unrealized_pnl=500.0,
    realized_pnl_today=100.0,
    total_trades=50,
    winning_trades=32,
    losing_trades=18
)

Getting Current Metrics

# Get current performance metrics
metrics = dashboard.get_current_metrics()

print(f"Total Return: {metrics['total_return_pct']:.2f}%")
print(f"Sharpe Ratio: {metrics['sharpe_ratio']:.2f}")
print(f"Max Drawdown: {metrics['max_drawdown_pct']:.2f}%")
print(f"Win Rate: {metrics['win_rate_pct']:.2f}%")

Generating Equity Curve

# Get equity curve for last 30 days
equity_curve = dashboard.get_equity_curve(days=30)

# Plot using your preferred library
timestamps = [point['timestamp'] for point in equity_curve]
equity = [point['equity'] for point in equity_curve]

Monthly Reports

# Get monthly report
report = dashboard.get_monthly_report(year=2026, month=1)

print(f"Monthly Return: {report['monthly_return_pct']:.2f}%")
print(f"Trades: {report['total_trades']}")
print(f"Win Rate: {report['win_rate_pct']:.2f}%")

# Get all monthly reports
all_reports = dashboard.get_all_monthly_reports()

Investor Summary

# Generate comprehensive investor summary
summary = dashboard.get_investor_summary()

# Export to file
filepath = dashboard.export_investor_report(output_dir='./reports')
print(f"Report saved to: {filepath}")

API Integration

Flask App Integration

from flask import Flask
from bot.dashboard_api import register_dashboard_routes

app = Flask(__name__)

# Register dashboard routes
register_dashboard_routes(app)

if __name__ == '__main__':
    app.run(port=5000)

API Usage Examples

Get Current Metrics

curl http://localhost:5000/api/v1/dashboard/metrics

Response:

{
  "success": true,
  "data": {
    "total_return_pct": 25.5,
    "annualized_return_pct": 45.2,
    "sharpe_ratio": 1.8,
    "max_drawdown_pct": 8.3,
    "win_rate_pct": 64.0
  }
}

Get Equity Curve

curl "http://localhost:5000/api/v1/dashboard/equity-curve?days=30"

Update Snapshot

curl -X POST http://localhost:5000/api/v1/dashboard/update-snapshot \
  -H "Content-Type: application/json" \
  -d '{
    "cash": 8000.0,
    "positions_value": 4500.0,
    "unrealized_pnl": 500.0,
    "realized_pnl_today": 100.0,
    "total_trades": 50,
    "winning_trades": 32,
    "losing_trades": 18
  }'

Get Investor Summary

curl http://localhost:5000/api/v1/dashboard/investor-summary

Response:

{
  "success": true,
  "data": {
    "user_id": "user123",
    "initial_capital": 10000.0,
    "current_nav": 12550.0,
    "total_return_pct": 25.5,
    "annualized_return_pct": 45.2,
    "sharpe_ratio": 1.8,
    "sortino_ratio": 2.1,
    "max_drawdown_pct": 8.3,
    "win_rate_pct": 64.0,
    "total_trades": 50,
    "active_strategies": 3,
    "diversification_score": 78.5
  }
}

Performance Metrics Explained

Total portfolio value including cash and positions:

NAV = Cash + Positions Market Value

Equity

Total capital available (same as NAV in this context):

Equity = Cash + Positions Value

Sharpe Ratio

Risk-adjusted return metric:

Sharpe = (Return - Risk_Free_Rate) / Volatility

Sortino Ratio

Like Sharpe but only penalizes downside volatility:

Sortino = (Return - Risk_Free_Rate) / Downside_Deviation

Maximum Drawdown

Largest peak-to-trough decline:

Max_DD = (Peak - Trough) / Peak × 100%

Win Rate

Percentage of winning trades:

Win_Rate = Winning_Trades / Total_Trades × 100%

Investor Report Format

The investor report includes:

  1. Executive Summary
    • Initial capital
    • Current NAV
    • Total return
    • Annualized return
  2. Performance Metrics
    • Sharpe and Sortino ratios
    • Maximum drawdown
    • Win rate
    • Trading activity
  3. Risk Metrics
    • Current drawdown
    • Volatility
    • Drawdown history
  4. Portfolio Composition
    • Active strategies
    • Strategy allocations
    • Diversification score
  5. Time Series Data
    • Equity curve
    • Drawdown curve
    • Monthly reports

Dashboard Update Frequency

Best Practices

1. Regular Snapshot Updates

# In your trading loop
if time_for_snapshot():
    dashboard.update_snapshot(
        cash=get_cash(),
        positions_value=get_positions_value(),
        unrealized_pnl=get_unrealized_pnl(),
        realized_pnl_today=get_realized_pnl_today(),
        total_trades=trade_count,
        winning_trades=win_count,
        losing_trades=loss_count
    )

2. Periodic State Saving

# Save state periodically
dashboard.save_state()

3. Monthly Report Generation

# Generate at end of month
from datetime import datetime

now = datetime.now()
report = dashboard.get_monthly_report(now.year, now.month)

4. Investor Communications

# Export report for investors
filepath = dashboard.export_investor_report()
send_to_investors(filepath)

Customization

Snapshot Interval

dashboard.snapshot_interval = timedelta(minutes=30)  # 30 min snapshots

Risk-Free Rate

# Adjust for Sharpe calculation
metrics_calculator = dashboard.metrics_calculator
sharpe = metrics_calculator.calculate_sharpe_ratio(risk_free_rate=0.03)  # 3%

Custom Metrics

Extend PerformanceMetricsCalculator to add custom metrics:

class CustomMetricsCalculator(PerformanceMetricsCalculator):
    def calculate_calmar_ratio(self):
        """Calmar ratio = Annualized Return / Max Drawdown"""
        metrics = self.calculate_metrics()
        if metrics.max_drawdown_pct > 0:
            return metrics.annualized_return_pct / metrics.max_drawdown_pct
        return 0.0

Troubleshooting

Missing Data

Incorrect Metrics

API Errors

Future Enhancements