Portfolio-Dashboard
Übersicht
Aggregieren und analysieren Sie Daten aus mehreren Bauprojekten für eine Sichtweise auf Portfolio-Ebene. Verfolgen Sie KPIs, identifizieren Sie Trends, vergleichen Sie die Projektleistung und unterstützen Sie strategische Ressourcenallokationen.
Portfolio-Analyse-Framework
┌─────────────────────────────────────────────────────────────────┐
│ PORTFOLIO-DASHBOARD │
├─────────────────────────────────────────────────────────────────┤
│ │
│ PROJEKT A PROJEKT B PROJEKT C PROJEKT D │
│ ↓ ↓ ↓ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ DATEN-AGGREGATION │ │
│ │ Kosten | Zeitplan | Sicherheit | Qualität | Risiko │ │
│ └─────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ PORTFOLIO-KPIs │ │
│ │ 📊 Gesamtwert 📈 Im Zeitplan % │ │
│ │ 💰 Im Budget % 🛡️ Sicherheitsrate │ │
│ │ ⚠️ Risikoscore 📋 Ressourcennutzung │ │
│ └─────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
Technische Implementierung
from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
from datetime import datetime, timedelta
from enum import Enum
import statistics
class ProjectStatus(Enum):
PLANNING = "planning"
ACTIVE = "active"
ON_HOLD = "on_hold"
COMPLETE = "complete"
CANCELLED = "cancelled"
class HealthStatus(Enum):
GREEN = "green"
YELLOW = "yellow"
RED = "red"
GREY = "grey"
@dataclass
class ProjectMetrics:
project_id: str
project_name: str
status: ProjectStatus
contract_value: float
percent_complete: float
planned_start: datetime
planned_end: datetime
actual_start: Optional[datetime]
forecast_end: datetime
schedule_variance_days: int = 0
budget: float
actual_cost: float
forecast_cost: float
cost_variance: float = 0.0
cpi: float = 1.0
spi: float = 1.0
recordable_incidents: int = 0
total_hours: float = 0
trir: float = 0.0
defects_open: int = 0
rework_cost: float = 0.0
risk_score: float = 0.0
critical_risks: int = 0
@property
def health(self) -> HealthStatus:
"""Ermittelt den allgemeinen Projektzustand."""
if self.status in [ProjectStatus.ON_HOLD, ProjectStatus.CANCELLED]:
return HealthStatus.GREY
if self.cpi < 0.85 or self.spi < 0.85 or self.critical_risks > 3:
return HealthStatus.RED
if self.cpi < 0.95 or self.spi < 0.95 or self.critical_risks > 0:
return HealthStatus.YELLOW
return HealthStatus.GREEN
@dataclass
class PortfolioSummary:
report_date: datetime
total_projects: int
active_projects: int
total_contract_value: float
total_budget: float
total_actual_cost: float
total_forecast_cost: float
avg_cpi: float
avg_spi: float
on_budget_pct: float
on_schedule_pct: float
portfolio_trir: float
total_incidents: int
green_count: int
yellow_count: int
red_count: int
cost_trend: str
schedule_trend: str
@dataclass
class ProjectComparison:
metric: str
projects: Dict[str, float]
avg: float
best: Tuple[str, float]
worst: Tuple[str, float]
class PortfolioDashboard:
"""Multi-Projekt-Portfolio-Analyse."""
THRESHOLDS = {
"cpi_warning": 0.95,
"cpi_critical": 0.85,
"spi_warning": 0.95,
"spi_critical": 0.85,
"trir_warning": 2.0,
"risk_score_warning": 7.0
}
def __init__(self, portfolio_name: str):
self.portfolio_name = portfolio_name
self.projects: Dict[str, ProjectMetrics] = {}
self.snapshots: List[Dict] = []
def add_project(self, metrics: ProjectMetrics):
"""Fügt ein Projekt zum Portfolio hinzu oder aktualisiert es."""
self.projects[metrics.project_id] = metrics
def import_projects(self, projects_data: List[Dict]) -> int:
"""Importiert mehrere Projekte aus Daten."""
count = 0
for p in projects_data:
metrics = ProjectMetrics(
project_id=p['id'],
project_name=p['name'],
status=ProjectStatus(p.get('status', 'active')),
contract_value=p['contract_value'],
percent_complete=p.get('percent_complete', 0),
planned_start=p['planned_start'],
planned_end=p['planned_end'],
actual_start=p.get('actual_start'),
forecast_end=p.get('forecast_end', p['planned_end']),
budget=p['budget'],
actual_cost=p.get('actual_cost', 0),
forecast_cost=p.get('forecast_cost', p['budget']),
cpi=p.get('cpi', 1.0),
spi=p.get('spi', 1.0),
recordable_incidents=p.get('incidents', 0),
total_hours=p.get('total_hours', 0),
risk_score=p.get('risk_score', 0),
critical_risks=p.get('critical_risks', 0)
)
metrics.cost_variance = metrics.budget - metrics.actual_cost
metrics.schedule_variance_days = (metrics.planned_end - metrics.forecast_end).days
if metrics.total_hours > 0:
metrics.trir = (metrics.recordable_incidents * 200000) / metrics.total_hours
self.add_project(metrics)
count += 1
return count
def get_active_projects(self) -> List[ProjectMetrics]:
"""Gibt eine Liste der aktiven Projekte zurück."""
return [p for p in self.projects.values()
if p.status == ProjectStatus.ACTIVE]
def calculate_portfolio_summary(self) -> PortfolioSummary:
"""Berechnet Zusammenfassungsmetriken auf Portfolio-Ebene."""
active = self.get_active_projects()
all_projects = list(self.projects.values())
if not all_projects:
return None
total_contract = sum(p.contract_value for p in all_projects)
total_budget = sum(p.budget for p in all_projects)
total_actual = sum(p.actual_cost for p in all_projects)
total_forecast = sum(p.forecast_cost for p in all_projects)
if total_budget > 0:
avg_cpi = sum(p.cpi * p.budget for p in active) / sum(p.budget for p in active) if active else 1.0
avg_spi = sum(p.spi * p.budget for p in active) / sum(p.budget for p in active) if active else 1.0
else:
avg_cpi = avg_spi = 1.0
on_budget = len([p for p in active if p.cpi >= 0.95])
on_schedule = len([p for p in active if p.spi >= 0.95])
on_budget_pct = (on_budget / len(active) * 100) if active else 100
on_schedule_pct = (on_schedule / len(active) * 100) if active else 100
total_incidents = sum(p.recordable_incidents for p in all_projects)
total_hours = sum(p.total_hours for p in all_projects)
portfolio_trir = (total_incidents * 200000 / total_hours) if total_hours > 0 else 0
green = len([p for p in active if p.health == HealthStatus.GREEN])
yellow = len([p for p in active if p.health == HealthStatus.YELLOW])
red = len([p for p in active if p.health == HealthStatus.RED])
cost_trend = "stabil"
schedule_trend = "stabil"
if self.snapshots:
prev = self.snapshots[-1]
if avg_cpi > prev.get('avg_cpi', 1.0):
cost_trend = "verbessernd"
elif avg_cpi < prev.get('avg_cpi', 1.0):
cost_trend = "verschlechternd"
if avg_spi > prev.get('avg_spi', 1.0):
schedule_trend = "verbessernd"
elif avg_spi < prev.get('avg_spi', 1.0):
schedule_trend = "verschlechternd"
return PortfolioSummary(
report_date=datetime.now(),
total_projects=len(all_projects),
active_projects=len(active),
total_contract_value=total_contract,
total_budget=total_budget,
total_actual_cost=total_actual,
total_forecast_cost=total_forecast,
avg_cpi=avg_cpi,
avg_spi=avg_spi,
on_budget_pct=on_budget_pct,
on_schedule_pct=on_schedule_pct,
portfolio_trir=portfolio_trir,
total_incidents=total_incidents,
green_count=green,
yellow_count=yellow,
red_count=red,
cost_trend=cost_trend,
schedule_trend=schedule_trend
)
def compare_projects(self, metric: str) -> ProjectComparison:
"""Vergleicht Projekte nach einer bestimmten Metrik."""
active = self.get_active_projects()
if not active:
return None
metric_map = {
"cpi": lambda p: p.cpi,
"spi": lambda p: p.spi,
"percent_complete": lambda p: p.percent_complete,
"cost_variance": lambda p: p.cost_variance,
"trir": lambda p: p.trir,
"risk_score": lambda p: p.risk_score
}
if metric not in metric_map:
raise ValueError(f"Unbekannte Metrik: {metric}")
getter = metric_map[metric]
values = {p.project_name: getter(p) for p in active}
avg = statistics.mean(values.values())
if metric in ["trir", "risk_score"]:
best = min(values.items(), key=lambda x: x[1])
worst = max(values.items(), key=lambda x: x[1])
else:
best = max(values.items(), key=lambda x: x[1])
worst = min(values.items(), key=lambda x: x[1])
return ProjectComparison(
metric=metric,
projects=values,
avg=avg,
best=best,
worst=worst
)
def get_projects_at_risk(self) -> List[ProjectMetrics]:
"""Gibt Projekte zurück, die Aufmerksamkeit benötigen."""
return [p for p in self.get_active_projects()
if p.health in [HealthStatus.YELLOW, HealthStatus.RED]]
def get_top_risks(self, limit: int = 10) -> List[Dict]:
"""Gibt die Top-Risiken im Portfolio zurück."""
risks = []
for p in self.get_active_projects():
if p.risk_score > 0:
risks.append({
"project": p.project_name,
"risk_score": p.risk_score,
"critical_risks": p.critical_risks,
"cpi": p.cpi,
"spi": p.spi
})
return sorted(risks, key=lambda x: -x['risk_score'])[:limit]
def forecast_cash_needs(self, months: int = 6) -> List[Dict]:
"""Prognostiziert den Liquiditätsbedarf im Portfolio."""
forecasts = []
for month in range(1, months + 1):
month_date = datetime.now() + timedelta(days=month * 30)
month_spend = 0
for p in self.get_active_projects():
remaining = p.forecast_cost - p.actual_cost
months_remaining = max(1, (p.forecast_end - datetime.now()).days / 30)
monthly_burn = remaining / months_remaining
month_spend += monthly_burn
forecasts.append({
"month": month_date.strftime("%Y-%m"),
"projected_spend": month_spend
})
return forecasts
def save_snapshot(self):
"""Speichert den aktuellen Zustand für Trendanalysen."""
summary = self.calculate_portfolio_summary()
if summary:
self.snapshots.append({
"date": datetime.now(),
"avg_cpi": summary.avg_cpi,
"avg_spi": summary.avg_spi,
"on_budget_pct": summary.on_budget_pct,
"on_schedule_pct": summary.on_schedule_pct,
"total_forecast": summary.total_forecast_cost
})
def generate_report(self) -> str:
"""Generiert einen Portfolio-Dashboard-Bericht."""
summary = self.calculate_portfolio_summary()
if not summary:
return "Keine Projekte im Portfolio"
lines = [
"# Portfolio-Dashboard",
"",
f"**Portfolio:** {self.portfolio_name}",
f"**Berichtsdatum:** {summary.report_date.strftime('%Y-%m-%d')}",
"",
"## Zusammenfassung für die Führungsebene",
"",
"| Metrik | Wert |",
"|--------|-------|",
f"| Gesamtprojekte | {summary.total_projects} ({summary.active_projects} aktiv) |",
f"| Gesamtauftragswert | ${summary.total_contract_value:,.0f} |",
f"| Gesamtbudget | ${summary.total_budget:,.0f} |",
f"| Tatsächliche Kosten bisher | ${summary.total_actual_cost:,.0f} |",
f"| Prognose bei Fertigstellung | ${summary.total_forecast_cost:,.0f} |",
f"| Durchschnittlicher CPI | {summary.avg_cpi:.2f} |",
f"| Durchschnittlicher SPI | {summary.avg_spi:.2f} |",
f"| Im Budget (%) | {summary.on_budget_pct:.0f}% |",
f"| Im Zeitplan (%) | {summary.on_schedule_pct:.0f}% |",
f"| Portfolio-TRIR | {summary.portfolio_trir:.2f} |",
f"| Gesamtunfälle | {summary.total_incidents} |",
"",
"## Projektzustand",
"",
f"| Gesundheitszustand | Anzahl |",
f"|-----------------|-------|",
f"| 🟢 Gesund | {summary.green_count} |",
f"| 🟡 Gefährdet | {summary.yellow_count} |",
f"| 🔴 Kritisch | {summary.red_count} |",
"",
"## Trends",
"",
f"| Trend | Ausrichtung |",
f"|-------|-------------|",
f"| Kostentrend | {summary.cost_trend} |",
f"| Zeitplantrend | {summary.schedule_trend} |",
"",
"## Empfehlungen",
"",
f"✅ **Projekte mit erhöhtem Risiko:** {len(self.get_projects_at_risk())} Projekte benötigen Aufmerksamkeit.",
]
return "\n".join(lines)
Verwendung
dashboard = PortfolioDashboard("Infrastruktur-Portfolio 2024")
projects = [
{
'id': 'PRJ-001',
'name': 'Hochhaus Nord',
'status': 'active',
'contract_value': 50000000,
'percent_complete': 45,
'planned_start': datetime(2024, 1, 1),
'planned_end': datetime(2025, 6, 30),
'forecast_end': datetime(2025, 7, 15),
'budget': 45000000,
'actual_cost': 20000000,
'forecast_cost': 46500000,
'cpi': 0.94,
'spi': 0.92,
'incidents': 2,
'total_hours': 150000,
'risk_score': 6.5,
'critical_risks': 2
},
]
dashboard.import_projects(projects)
summary = dashboard.calculate_portfolio_summary()
print(f"Budgeteinhaltung: {summary.on_budget_pct:.1f}%")
print(f"Zeitplaneinhaltung: {summary.on_schedule_pct:.1f}%")
top_risks = dashboard.get_top_risks()
for risk in top_risks:
print(f"{risk['project']}: Risikoscore {risk['risk_score']}")
comparison = dashboard.compare_projects("cpi")
print(f"Bestes Projekt: {comparison.best[0]} ({comparison.best[1]:.2f})")
print(f"Schlechtestes Projekt: {comparison.worst[0]} ({comparison.worst[1]:.2f})")
forecasts = dashboard.forecast_cash_needs(months=6)
for f in forecasts:
print(f"{f['month']}: ${f['projected_spend']:,.0f}")
dashboard.save_snapshot()
report = dashboard.generate_report()
print(report)
API-Referenz
PortfolioDashboard
| Methode | Beschreibung |
|---|
add_project(metrics) | Ein Projekt zum Portfolio hinzufügen oder aktualisieren |
import_projects(data) | Mehrere Projekte aus einer Liste von Dictionaries importieren |
get_active_projects() | Alle aktiven Projekte abrufen |
calculate_portfolio_summary() | Portfolio-Zusammenfassungsmetriken berechnen |
compare_projects(metric) | Projekte nach einer bestimmten Metrik vergleichen |
get_projects_at_risk() | Projekte mit erhöhtem Risiko identifizieren |
get_top_risks(limit) | Top-Risiken im Portfolio abrufen |
forecast_cash_needs(months) | Zukünftigen Liquiditätsbedarf prognostizieren |
save_snapshot() | Aktuellen Zustand für Trendanalyse speichern |
generate_report() | Menschlich lesbaren Dashboard-Bericht generieren |
Metriken für den Vergleich
| Metrik | Beschreibung | Interpretation |
|---|
cpi | Kosten-Leistungs-Index (Earned Value / Actual Cost) | Höher ist besser (>= 1.0 = im Budget) |
spi | Zeitplan-Leistungs-Index (Earned Value / Planned Value) | Höher ist besser (>= 1.0 = im Zeitplan) |
percent_complete | Abschlussprozentsatz | Höher ist besser (fortgeschritten) |
cost_variance | Budget - Tatsächliche Kosten | Höher ist besser (positiv = unter Budget) |
trir | Gesamtunfallrate meldepflichtiger Vorfälle | Niedriger ist besser |
risk_score | Gesamtrisikobewertung | Niedriger ist besser |
Beispiele für die Integration
CSV-Import
import csv
def import_from_csv(dashboard: PortfolioDashboard, filepath: str):
with open(filepath, 'r') as f:
reader = csv.DictReader(f)
projects = []
for row in reader:
projects.append({
'id': row['project_id'],
'name': row['project_name'],
'status': row.get('status', 'active'),
'contract_value': float(row['contract_value']),
'percent_complete': float(row.get('percent_complete', 0)),
'planned_start': datetime.strptime(row['planned_start'], '%Y-%m-%d'),
'planned_end': datetime.strptime(row['planned_end'], '%Y-%m-%d'),
'budget': float(row['budget']),
'actual_cost': float(row.get('actual_cost', 0)),
'forecast_cost': float(row.get('forecast_cost', row['budget'])),
'cpi': float(row.get('cpi', 1.0)),
'spi': float(row.get('spi', 1.0)),
})
return dashboard.import_projects(projects)
API-Integration
import requests
def import_from_api(dashboard: PortfolioDashboard, api_url: str, api_key: str):
headers = {'Authorization': f'Bearer {api_key}'}
response = requests.get(f"{api_url}/projects", headers=headers)
projects = response.json()
for p in projects:
p['planned_start'] = datetime.fromisoformat(p['planned_start'])
p['planned_end'] = datetime.fromisoformat(p['planned_end'])
if 'forecast_end' in p:
p['forecast_end'] = datetime.fromisoformat(p['forecast_end'])
if 'actual_start' in p:
p['actual_start'] = datetime.fromisoformat(p['actual_start'])
return dashboard.import_projects(projects)
Best Practices
- Regelmäßige Snapshots: Rufen Sie
save_snapshot() regelmäßig auf (z. B. wöchentlich oder monatlich), um Trendanalysen zu ermöglichen.
- Datenqualität: Stellen Sie sicher, dass importierte Projektdaten genaue CPI/SPI-Werte enthalten.
- Schwellenwerte: Passen Sie die
THRESHOLDS-Werte an die Risikotoleranz Ihrer Organisation an.
- Kombinierte Analyse: Verwenden Sie
get_projects_at_risk() zusammen mit compare_projects(), um gezielt in Problembereichen zu bohren.
- Liquiditätsplanung: Verwenden Sie
forecast_cash_needs(), um den Finanzierungsbedarf für die nächsten Quartale vorherzusehen.
Einschränkungen
- Keine Echtzeit-Datenintegration (erfordert manuellen Import oder API-Aufrufe)
- Vereinfachte lineare Prognose für den Liquiditätsbedarf
- Keine granulare Projektphasen-Analyse
- Keine Multi-Währungs-Unterstützung (geht von einer einheitlichen Währung aus)