Board Presentation
Auto-generated quarterly report for board meetings. Updated every 90 days.
đ
Last generated: {new Date().toLocaleDateString()}
đ Refreshes quarterly with latest metrics
);
}
```
#### Step 4: Database Schema (1 hour)
```sql
CREATE TABLE board_reports (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
tenant_id UUID NOT NULL REFERENCES tenants(id),
report_date DATE DEFAULT CURRENT_DATE,
cyber_health_score DECIMAL,
previous_score DECIMAL,
top_risks JSONB,
remediation_progress JSONB,
financial_impact_estimate BIGINT,
pdf_path VARCHAR,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
created_by UUID REFERENCES users(id),
UNIQUE(tenant_id, report_date)
);
CREATE INDEX idx_board_reports_tenant_date ON board_reports(tenant_id, report_date);
```
### Deployment (2 hours)
- Add reportlab to requirements.txt
- Deploy backend update
- Deploy frontend update
- Add to dashboard
**Total Implementation Time**: ~14 hours
**Revenue Impact**: $30K-$40K/year
**Customer Delight**: 9/10 (immediate board meeting use)
---
## đ° Feature #2: INSURANCE SAVINGS ESTIMATOR (10 days)
### What to Build
Calculate potential cyber insurance premium reduction based on cyber health improvements.
### Why It's Perfect for Quick Win
- Uses existing risk data (cyber health score)
- Simple calculations (no complex ML)
- High ROI visibility (customers see $50K-$200K savings)
- Can generate partner revenue (insurance brokers)
### Implementation Steps
#### Step 1: Create Savings Calculator Service (2 hours)
```python
# backend/app/services/insurance_calculator.py
class InsuranceSavingsCalculator:
# Industry benchmarks for premium calculation
SCORE_TO_PREMIUM_BASELINE = {
# Lower score = higher premium
50: 2.5, # $250K annual premium for 50 score
60: 1.8, # $180K for 60 score
70: 1.3, # $130K for 70 score
80: 0.8, # $80K for 80 score
90: 0.4, # $40K for 90 score (best rate)
}
def estimate_annual_premium(self, cyber_health_score: float, revenue: float) -> float:
"""
Estimate cyber insurance premium based on cyber health score.
Formula: Base Premium = Revenue à Score Multiplier
"""
# Find multiplier for score (interpolate between benchmarks)
multiplier = self.get_score_multiplier(cyber_health_score)
# Revenue in millions
revenue_millions = revenue / 1_000_000
# Base premium (annual)
base_premium = revenue_millions * multiplier * 100_000
return base_premium
def get_score_multiplier(self, score: float) -> float:
"""Get insurance premium multiplier for score (0-1 scale)"""
# Higher score = lower premium
# Score 90 = 0.4x (best rates)
# Score 50 = 2.5x (worst rates)
if score >= 90:
return 0.4
elif score >= 80:
return 0.8
elif score >= 70:
return 1.3
elif score >= 60:
return 1.8
else:
return 2.5
def calculate_savings(self,
current_score: float,
target_score: float,
annual_revenue: float) -> dict:
"""Calculate premium savings from score improvement"""
current_premium = self.estimate_annual_premium(current_score, annual_revenue)
target_premium = self.estimate_annual_premium(target_score, annual_revenue)
annual_savings = current_premium - target_premium
# 3-year savings
three_year_savings = annual_savings * 3
return {
"current_premium": round(current_premium, 2),
"target_premium": round(target_premium, 2),
"annual_savings": round(annual_savings, 2),
"three_year_savings": round(three_year_savings, 2),
"premium_reduction_percent": round((annual_savings / current_premium * 100), 1) if current_premium > 0 else 0,
"roi_multiplier": round((three_year_savings / 100_000), 1), # Assuming $100K TrustOS cost
}
def get_remediation_roi(self, finding: dict, current_score: float, annual_revenue: float) -> dict:
"""Calculate insurance savings from fixing a specific finding"""
# Estimate score improvement from fixing this finding
score_improvement = self.estimate_score_improvement(finding['severity'], finding['category'])
target_score = min(current_score + score_improvement, 99)
savings = self.calculate_savings(current_score, target_score, annual_revenue)
return {
"finding_id": finding['id'],
"finding_title": finding['title'],
"estimated_score_improvement": score_improvement,
"annual_savings_if_fixed": savings['annual_savings'],
"roi_vs_effort": round(savings['annual_savings'] / 100, 2), # Assuming 100 effort units
}
def estimate_score_improvement(self, severity: str, category: str) -> float:
"""Estimate cyber health score improvement from fixing finding"""
severity_impact = {
"critical": 3.0,
"high": 1.5,
"medium": 0.8,
"low": 0.2,
}
category_multiplier = {
"external_exposure": 1.5,
"credential_exposure": 1.3,
"cloud_posture": 1.2,
"infrastructure": 1.0,
"application": 0.9,
"digital_footprint": 0.8,
}
base_impact = severity_impact.get(severity, 1.0)
multiplier = category_multiplier.get(category, 1.0)
return base_impact * multiplier
```
#### Step 2: Add API Endpoints (2 hours)
```python
# backend/app/api/routes/insurance.py (new file)
from fastapi import APIRouter, Depends, HTTPException
from app.services.insurance_calculator import InsuranceSavingsCalculator
router = APIRouter(prefix="/insurance", tags=["insurance"])
@router.post("/estimate/{tenant_id}")
async def estimate_insurance_savings(
tenant_id: str,
annual_revenue: float,
target_score: float = 85.0,
payload: dict = Depends(require_executive_or_above),
db: AsyncSession = Depends(get_db),
):
"""Estimate insurance premium savings from cyber health improvement"""
if payload.get("role") != "trustos_admin" and payload.get("tenant_id") != tenant_id:
raise HTTPException(status_code=403, detail="Access denied")
# Get current cyber health score
dashboard = await get_dashboard_data(tenant_id, db)
current_score = dashboard['current_score']
calculator = InsuranceSavingsCalculator()
savings = calculator.calculate_savings(current_score, target_score, annual_revenue)
return {
**savings,
"current_score": current_score,
"target_score": target_score,
"annual_revenue": annual_revenue,
}
@router.get("/finding-roi/{finding_id}")
async def get_finding_insurance_roi(
finding_id: str,
annual_revenue: float,
payload: dict = Depends(require_executive_or_above),
db: AsyncSession = Depends(get_db),
):
"""Calculate insurance savings from fixing a specific finding"""
finding = await get_finding(finding_id, db)
dashboard = await get_dashboard_data(finding.tenant_id, db)
if payload.get("tenant_id") != finding.tenant_id:
raise HTTPException(status_code=403, detail="Access denied")
calculator = InsuranceSavingsCalculator()
roi = calculator.get_remediation_roi(
finding.dict(),
dashboard['current_score'],
annual_revenue
)
return roi
```
#### Step 3: Frontend Component (3 hours)
```typescript
// frontend/src/app/dashboard/InsuranceSavingsCard.tsx
"use client";
import { useState, useEffect } from "react";
import { DollarSign, TrendingDown } from "lucide-react";
import { api } from "@/lib/api";
export default function InsuranceSavingsCard({
tenantId,
annualRevenue
}: {
tenantId: string;
annualRevenue: number;
}) {
const [savings, setSavings] = useState