Portfolio-Dashboard
Übersicht
Daten aus mehreren Bauprojekten aggregieren und analysieren, um Transparenz auf Portfolioebene zu schaffen. Verfolgen Sie KPIs, identifizieren Sie Trends, vergleichen Sie die Projektleistung und unterstützen Sie strategische Ressourcenallokationsentscheidungen.
Portfolio-Analyse-Framework
┌─────────────────────────────────────────────────────────────────┐
│ PORTFOLIO-DASHBOARD │
├─────────────────────────────────────────────────────────────────┤
│ │
│ PROJEKT A PROJEKT B PROJEKT C PROJEKT D │
│ ↓ ↓ ↓ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ DATENAGGREGATION │ │
│ │ Kosten | Zeitplan | Sicherheit | Qualität | Risiko │ │
│ └─────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ PORTFOLIO-KPIs │ │
│ │ 📊 Gesamtwert 📈 Termintreue % │ │
│ │ 💰 Budgettreue % 🛡️ Sicherheitsrate │ │
│ │ ⚠️ Risikoscore 📋 Ressourcenauslastung │ │
│ └─────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
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 ProjektStatus(Enum):
PLANUNG = "planning"
AKTIV = "active"
PAUSIERT = "on_hold"
ABGESCHLOSSEN = "complete"
STORNIERT = "cancelled"
class Gesundheitsstatus(Enum):
GRUEN = "green" # Im Plan
GELB = "yellow" # Gefährdet
ROT = "red" # Kritisch
GRAU = "grey" # Nicht gestartet/pausiert
@dataclass
class Projektkennzahlen:
projekt_id: str
projekt_name: str
status: ProjektStatus
vertragswert: float
prozent_abgeschlossen: float
# Zeitplan
geplanter_start: datetime
geplantes_ende: datetime
tatsaechlicher_start: Optional[datetime]
prognose_ende: datetime
terminabweichung_tage: int = 0
# Kosten
budget: float
tatsaechliche_kosten: float
prognosekosten: float
kostenabweichung: float = 0.0
cpi: float = 1.0
spi: float = 1.0
# Sicherheit
meldepflichtige_vorfaelle: int = 0
gesamtstunden: float = 0
trir: float = 0.0
# Qualität
offene_maengel: int = 0
nacharbeitskosten: float = 0.0
# Risiko
risikoscore: float = 0.0
kritische_risiken: int = 0
@property
def gesundheit(self) -> Gesundheitsstatus:
"""Bestimmt den Gesamtgesundheitsstatus des Projekts."""
if self.status in [ProjektStatus.PAUSIERT, ProjektStatus.STORNIERT]:
return Gesundheitsstatus.GRAU
# Kritisch, wenn deutlich über Budget/Zeitplan
if self.cpi < 0.85 or self.spi < 0.85 or self.kritische_risiken > 3:
return Gesundheitsstatus.ROT
# Gefährdet, wenn mäßig vom Plan abweicht
if self.cpi < 0.95 or self.spi < 0.95 or self.kritische_risiken > 0:
return Gesundheitsstatus.GELB
return Gesundheitsstatus.GRUEN
@dataclass
class Portfoliozusammenfassung:
berichtsdatum: datetime
gesamte_projekte: int
aktive_projekte: int
gesamter_vertragswert: float
gesamtbudget: float
gesamte_tatsaechliche_kosten: float
gesamte_prognosekosten: float
# Leistung
durchschnittlicher_cpi: float
durchschnittlicher_spi: float
budgettreue_prozent: float
termintreue_prozent: float
# Sicherheit
portfolio_trir: float
gesamte_vorfaelle: int
# Gesundheitsverteilung
gruene_anzahl: int
gelbe_anzahl: int
rote_anzahl: int
# Trends
kostentrend: str
termintrend: str
@dataclass
class Projektvergleich:
kennzahl: str
projekte: Dict[str, float]
durchschnitt: float
bestes: Tuple[str, float]
schlechtestes: Tuple[str, float]
class PortfolioDashboard:
"""Multi-Projekt-Portfolio-Analyse."""
# Gesundheitsschwellenwerte
SCHWELLENWERTE = {
"cpi_warnung": 0.95,
"cpi_kritisch": 0.85,
"spi_warnung": 0.95,
"spi_kritisch": 0.85,
"trir_warnung": 2.0,
"risikoscore_warnung": 7.0
}
def __init__(self, portfolio_name: str):
self.portfolio_name = portfolio_name
self.projekte: Dict[str, Projektkennzahlen] = {}
self.momentaufnahmen: List[Dict] = [] # Historische Daten
def projekt_hinzufuegen(self, kennzahlen: Projektkennzahlen):
"""Projekt zum Portfolio hinzufügen oder aktualisieren."""
self.projekte[kennzahlen.projekt_id] = kennzahlen
def projekte_importieren(self, projektdaten: List[Dict]) -> int:
"""Mehrere Projekte aus Daten importieren."""
anzahl = 0
for p in projektdaten:
kennzahlen = Projektkennzahlen(
projekt_id=p['id'],
projekt_name=p['name'],
status=ProjektStatus(p.get('status', 'active')),
vertragswert=p['contract_value'],
prozent_abgeschlossen=p.get('percent_complete', 0),
geplanter_start=p['planned_start'],
geplantes_ende=p['planned_end'],
tatsaechlicher_start=p.get('actual_start'),
prognose_ende=p.get('forecast_end', p['planned_end']),
budget=p['budget'],
tatsaechliche_kosten=p.get('actual_cost', 0),
prognosekosten=p.get('forecast_cost', p['budget']),
cpi=p.get('cpi', 1.0),
spi=p.get('spi', 1.0),
meldepflichtige_vorfaelle=p.get('incidents', 0),
gesamtstunden=p.get('total_hours', 0),
risikoscore=p.get('risk_score', 0),
kritische_risiken=p.get('critical_risks', 0)
)
# Abgeleitete Kennzahlen berechnen
kennzahlen.kostenabweichung = kennzahlen.budget - kennzahlen.tatsaechliche_kosten
kennzahlen.terminabweichung_tage = (kennzahlen.geplantes_ende - kennzahlen.prognose_ende).days
if kennzahlen.gesamtstunden > 0:
kennzahlen.trir = (kennzahlen.meldepflichtige_vorfaelle * 200000) / kennzahlen.gesamtstunden
self.projekt_hinzufuegen(kennzahlen)
anzahl += 1
return anzahl
def aktive_projekte_abrufen(self) -> List[Projektkennzahlen]:
"""Liste aktiver Projekte abrufen."""
return [p for p in self.projekte.values()
if p.status == ProjektStatus.AKTIV]
def portfoliozusammenfassung_berechnen(self) -> Portfoliozusammenfassung:
"""Portfolioübergreifende Zusammenfassungskennzahlen berechnen."""
aktiv = self.aktive_projekte_abrufen()
alle_projekte = list(self.projekte.values())
if not alle_projekte:
return None
# Summen
gesamter_vertragswert = sum(p.vertragswert for p in alle_projekte)
gesamtbudget = sum(p.budget for p in alle_projekte)
gesamte_tatsaechliche_kosten = sum(p.tatsaechliche_kosten for p in alle_projekte)
gesamte_prognosekosten = sum(p.prognosekosten for p in alle_projekte)
# Durchschnittliche Leistung (gewichtet nach Budget)
if gesamtbudget > 0:
durchschnittlicher_cpi = sum(p.cpi * p.budget for p in aktiv) / sum(p.budget for p in aktiv) if aktiv else 1.0
durchschnittlicher_spi = sum(p.spi * p.budget for p in aktiv) / sum(p.budget for p in aktiv) if aktiv else 1.0
else:
durchschnittlicher_cpi = durchschnittlicher_spi = 1.0
# Budget-/Termintreue in Prozent
budgettreu = len([p for p in aktiv if p.cpi >= 0.95])
termintreu = len([p for p in aktiv if p.spi >= 0.95])
budgettreue_prozent = (budgettreu / len(aktiv) * 100) if aktiv else 100
termintreue_prozent = (termintreu / len(aktiv) * 100) if aktiv else 100
# Sicherheitskennzahlen
gesamte_vorfaelle = sum(p.meldepflichtige_vorfaelle for p in alle_projekte)
gesamtstunden = sum(p.gesamtstunden for p in alle_projekte)
portfolio_trir = (gesamte_vorfaelle * 200000 / gesamtstunden) if gesamtstunden > 0 else 0
# Gesundheitsverteilung
gruen = len([p for p in aktiv if p.gesundheit == Gesundheitsstatus.GRUEN])
gelb = len([p for p in aktiv if p.gesundheit == Gesundheitsstatus.GELB])
rot = len([p for p in aktiv if p.gesundheit == Gesundheitsstatus.ROT])
# Trends (mit vorheriger Momentaufnahme vergleichen falls vorhanden)
kostentrend = "stabil"
termintrend = "stabil"
if self.momentaufnahmen:
vorherige = self.momentaufnahmen[-1]
if durchschnittlicher_cpi > vorherige.get('avg_cpi', 1.0):
kostentrend = "verbessernd"
elif durchschnittlicher_cpi < vorherige.get('avg_cpi', 1.0):
kostentrend = "verschlechternd"
if durchschnittlicher_spi > vorherige.get('avg_spi', 1.0):
termintrend = "verbessernd"
elif durchschnittlicher_spi < vorherige.get('avg_spi', 1.0):
termintrend = "verschlechternd"
return Portfoliozusammenfassung(
berichtsdatum=datetime.now(),
gesamte_projekte=len(alle_projekte),
aktive_projekte=len(aktiv),
gesamter_vertragswert=gesamter_vertragswert,
gesamtbudget=gesamtbudget,
gesamte_tatsaechliche_kosten=gesamte_tatsaechliche_kosten,
gesamte_prognosekosten=gesamte_prognosekosten,
durchschnittlicher_cpi=durchschnittlicher_cpi,
durchschnittlicher_spi=durchschnittlicher_spi,
budgettreue_prozent=budgettreue_prozent,
termintreue_prozent=termintreue_prozent,
portfolio_trir=portfolio_trir,
gesamte_vorfaelle=gesamte_vorfaelle,
gruene_anzahl=gruen,
gelbe_anzahl=gelb,
rote_anzahl=rot,
kostentrend=kostentrend,
termintrend=termintrend
)
def projekte_vergleichen(self, kennzahl: str) -> Projektvergleich:
"""Projekte nach einer bestimmten Kennzahl vergleichen."""
aktiv = self.aktive_projekte_abrufen()
if nicht aktiv:
return None
kennzahl_map = {
"cpi": lambda p: p.cpi,
"spi": lambda p: p.spi,
"prozent_abgeschlossen": lambda p: p.prozent_abgeschlossen,
"kostenabweichung": lambda p: p.kostenabweichung,
"trir": lambda p: p.trir,
"risikoscore": lambda p: p.risikoscore
}
if kennzahl not in kennzahl_map:
raise ValueError(f"Unbekannte Kennzahl: {kennzahl}")
getter = kennzahl_map[kennzahl]
werte = {p.projekt_name: getter(p) for p in aktiv}
durchschnitt = statistics.mean(werte.values())
# Bestes/Schlechtestes hängt von der Kennzahl ab (höherer CPI gut, niedrigerer TRIR gut)
if kennzahl in ["trir", "risikoscore"]:
bestes = min(werte.items(), key=lambda x: x[1])
schlechtestes = max(werte.items(), key=lambda x: x[1])
else:
bestes = max(werte.items(), key=lambda x: x[1])
schlechtestes = min(werte.items(), key=lambda x: x[1])
return Projektvergleich(
kennzahl=kennzahl,
projekte=werte,
durchschnitt=durchschnitt,
bestes=bestes,
schlechtestes=schlechtestes
)
def gefaehrdete_projekte_abrufen(self) -> List[Projektkennzahlen]:
"""Projekte abrufen, die Aufmerksamkeit benötigen."""
return [p for p in self.aktive_projekte_abrufen()
if p.gesundheit in [Gesundheitsstatus.GELB, Gesundheitsstatus.ROT]]
def top_risiken_abrufen(self, limit: int = 10) -> List[Dict]:
"""Top-Risiken im gesamten Portfolio abrufen."""
risiken = []
for p in self.aktive_projekte_abrufen():
if p.risikoscore > 0:
risiken.append({
"projekt": p.projekt_name,
"risikoscore": p.risikoscore,
"kritische_risiken": p.kritische_risiken,
"cpi": p.cpi,
"spi": p.spi
})
return sorted(risiken, key=lambda x: -x['risikoscore'])[:limit]
def liquiditaetsbedarf_prognostizieren(self, monate: int = 6) -> List[Dict]:
"""Liquiditätsbedarf im gesamten Portfolio prognostizieren."""
prognosen = []
for monat in range(1, monate + 1):
monats_datum = datetime.now() + timedelta(days=monat * 30)
monatsausgaben = 0
for p in self.aktive_projekte_abrufen():
# Einfache lineare Projektion basierend auf verbleibender Arbeit
verbleibend = p.prognosekosten - p.tatsaechliche_kosten
verbleibende_monate = max(1, (p.prognose_ende - datetime.now()).days / 30)
monatliche_rate = verbleibend / verbleibende_monate
monatsausgaben += monatliche_rate
prognosen.append({
"monat": monats_datum.strftime("%Y-%m"),
"prognostizierte_ausgaben": monatsausgaben
})
return prognosen
def momentaufnahme_speichern(self):
"""Aktuellen Zustand für Trendanalyse speichern."""
zusammenfassung = self.portfoliozusammenfassung_berechnen()
if zusammenfassung:
self.momentaufnahmen.append({
"datum": datetime.now(),
"durchschnittlicher_cpi": zusammenfassung.durchschnittlicher_cpi,
"durchschnittlicher_spi": zusammenfassung.durchschnittlicher_spi,
"budgettreue_prozent": zusammenfassung.budgettreue_prozent,
"termintreue_prozent": zusammenfassung.termintreue_prozent,
"gesamte_prognosekosten": zusammenfassung.gesamte_prognosekosten
})
def bericht_generieren(self) -> str:
"""Portfolio-Dashboard-Bericht generieren."""
zusammenfassung = self.portfoliozusammenfassung_berechnen()
if nicht zusammenfassung:
return "Keine Projekte im Portfolio"
zeilen = [
"# Portfolio-Dashboard",
"",
f"**Portfolio:** {self.portfolio_name}",
f"**Berichtsdatum:** {zusammenfassung.berichtsdatum.strftime('%Y-%m-%d')}",
"",
"## Zusammenfassung für die Geschäftsleitung",
"",
f"| Kennzahl | Wert |",
f"|--------|-------|",
f"| Gesamte Projekte | {zusammenfassung.gesamte_projekte} ({zusammenfassung.aktive_projekte} aktiv) |",
f"| Gesamter Vertragswert | ${zusammenfassung.gesamter_vertragswert:,.0f} |",
f"| Gesamtbudget | ${zusammenfassung.gesamtbudget:,.0f} |",
f"| Tatsächliche Kosten bisher | ${zusammenfassung.gesamte_tatsaechliche_kosten:,.0f} |",
f"| Prognose bei Abschluss | ${zusammenfassung.gesamte_prognosekosten:,.0f} |",
"",
"## Leistungskennzahlen",
"",
f"| Kennzahl | Wert | Trend |",
f"|--------|-------|-------|",
f"| Durchschnittlicher CPI | {zusammenfassung.durchschnittlicher_cpi:.2f} | {zusammenfassung.kostentrend} |",
f"| Durchschnittlicher SPI | {zusammenfassung.durchschnittlicher_spi:.2f} | {zusammenfassung.termintrend} |",
f"| Budgettreue (%) | {zusammenfassung.budgettreue_prozent:.1f}% | |",
f"| Termintreue (%) | {zusammenfassung.termintreue_prozent:.1f}% | |",
"",
"## Gesundheit der Projekte",
"",
f"- 🟢 Gesund: {zusammenfassung.gruene_anzahl}",
f"- 🟡 Gefährdet: {zusammenfassung.gelbe_anzahl}",
f"- 🔴 Kritisch: {zusammenfassung.rote_anzahl}",
"",
"## Sicherheitskennzahlen",
"",
f"| Kennzahl | Wert |",
f"|--------|-------|",
f"| TRIR (Gesamte meldepflichtige Vorfallrate) | {zusammenfassung.portfolio_trir:.2f} |",
f"| Gesamte meldepflichtige Vorfälle | {zusammenfassung.gesamte_vorfaelle} |",
"",
"## Nächste Schritte",
"",
"1. Gefährdete und kritische Projekte überprüfen",
"2. Ressourcenzuweisung bei Bedarf anpassen",
"3. Ursachen der Kosten- und Terminabweichungen untersuchen",
"4. Sicherheitsprogramme für Projektstandorte mit hohem TRIR aktualisieren",
""
]
return "\n".join(zeilen)
# Alias-Methoden für Abwärtskompatibilität (optional)
hinzufuegen_projekt = projekt_hinzufuegen
importiere_projekte = projekte_importieren
abrufen_aktive_projekte = aktive_projekte_abrufen
berechnen_zusammenfassung = portfoliozusammenfassung_berechnen
vergleiche_projekte = projekte_vergleichen
abrufen_gefaehrdete_projekte = gefaehrdete_projekte_abrufen
abrufen_top_risiken = top_risiken_abrufen
prognostiziere_liquiditaet = liquiditaetsbedarf_prognostizieren
speichere_momentaufnahme = momentaufnahme_speichern
generiere_bericht = bericht_generieren
Verwendung
# Dashboard initialisieren
dashboard = PortfolioDashboard("Hochbauabteilung")
# Projekte aus einer Datenquelle importieren
dashboard.importiere_projekte(projekt_daten)
# Portfoliozusammenfassung abrufen
zusammenfassung = dashboard.portfoliozusammenfassung_berechnen()
# Bericht generieren
bericht = dashboard.bericht_generieren()
print(bericht)
# Projekte vergleichen
vergleich = dashboard.projekte_vergleichen("cpi")
print(f"Bester: {vergleich.bestes[0]} ({vergleich.bestes[1]:.2f})")
print(f"Schlechtester: {vergleich.schlechtestes[0]} ({vergleich.schlechtestes[1]:.2f})")
# Gefährdete Projekte identifizieren
ergebnisse = dashboard.gefaehrdete_projekte_abrufen()
for projekt in ergebnisse:
print(f"{projekt.projekt_name}: {projekt.gesundheit.value}")
# Cashflow prognostizieren
cashflow = dashboard.liquiditaetsbedarf_prognostizieren(monate=12)
# Trendverfolgung durch regelmäßige Momentaufnahmen
dashboard.momentaufnahme_speichern()
Anpassungsmöglichkeiten
- Datenquellen: Ersetzen Sie
projekt_hinzufuegendurch Datenbankabfragen, API-Aufrufe oder CSV-Importe. - Kennzahlen: Fügen Sie benutzerdefinierte Kennzahlen über die
kennzahl_mapinprojekte_vergleichenhinzu. - Schwellenwerte: Passen Sie
SCHWELLENWERTEfür Ihren spezifischen Risikoappetit an. - Visualisierung: Integrieren Sie die Ausgabe in Ihre bevorzugte Dashboard-Plattform (Grafana, Tableau, benutzerdefiniertes Web-Frontend).
- Integration: Nutzen Sie die Dataclasses als Grundlage für die Generierung von REST-API-Antworten zum Abruf von Portfolio-Daten über HTTP.