포트폴리오 대시보드은(는) 무엇을 하나요?
개요
여러 건설 프로젝트의 데이터를 집계하고 분석하여 포트폴리오 수준의 가시성을 확보합니다. KPI를 추적하고, 트렌드를 식별하며, 프로젝트 성과를 비교하고, 전략적 자원 할당 결정을 지원합니다.
포트폴리오 분석 프레임워크
┌─────────────────────────────────────────────────────────────────┐
│ 포트폴리오 대시보드 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 프로젝트 A 프로젝트 B 프로젝트 C 프로젝트 D │
│ ↓ ↓ ↓ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ 데이터 수집 │ │
│ │ 비용 | 일정 | 안전 | 품질 | 위험 │ │
│ └─────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ 포트폴리오 KPI │ │
│ │ 📊 총 계약액 📈 일정 준수율 │ │
│ │ 💰 예산 준수율 🛡️ 안전율 │ │
│ │ ⚠️ 위험 점수 📋 자원 활용률 │ │
│ └─────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
기술 구현
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:
"""프로젝트 전체 상태를 결정합니다."""
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:
"""다중 프로젝트 포트폴리오 분석."""
# 상태 임계값
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):
"""포트폴리오에 프로젝트를 추가하거나 업데이트합니다."""
self.projects[metrics.project_id] = metrics
def import_projects(self, projects_data: List[Dict]) -> int:
"""데이터에서 여러 프로젝트를 가져옵니다."""
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]:
"""활성 프로젝트 목록을 가져옵니다."""
return [p for p in self.projects.values()
if p.status == ProjectStatus.ACTIVE]
def calculate_portfolio_summary(self) -> PortfolioSummary:
"""포트폴리오 수준의 요약 지표를 계산합니다."""
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 = "stable"
schedule_trend = "stable"
if self.snapshots:
prev = self.snapshots[-1]
if avg_cpi > prev.get('avg_cpi', 1.0):
cost_trend = "improving"
elif avg_cpi < prev.get('avg_cpi', 1.0):
cost_trend = "declining"
if avg_spi > prev.get('avg_spi', 1.0):
schedule_trend = "improving"
elif avg_spi < prev.get('avg_spi', 1.0):
schedule_trend = "declining"
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:
"""특정 지표로 프로젝트를 비교합니다."""
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"Unknown metric: {metric}")
getter = metric_map[metric]
values = {p.project_name: getter(p) for p in active}
avg = statistics.mean(values.values())
# 최고/최악은 지표에 따라 다름 (CPI 높음 좋음, TRIR 낮음 좋음)
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]:
"""주의가 필요한 프로젝트를 가져옵니다."""
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]:
"""포트폴리오 전체에서 상위 위험을 가져옵니다."""
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]:
"""포트폴리오 전체의 현금 필요량을 예측합니다."""
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):
"""트렌드 분석을 위해 현재 상태를 저장합니다."""
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:
"""포트폴리오 대시보드 보고서를 생성합니다."""
summary = self.calculate_portfolio_summary()
if not summary:
return "포트폴리오에 프로젝트가 없습니다"
lines = [
"# 포트폴리오 대시보드",
"",
f"**포트폴리오:** {self.portfolio_name}",
f"**보고서 날짜:** {summary.report_date.strftime('%Y-%m-%d')}",
"",
"## 경영진 요약",
"",
f"| 지표 | 값 |",
f"|--------|-------|",
f"| 총 프로젝트 | {summary.total_projects} ({summary.active_projects} 활성) |",
f"| 총 계약액 | ${summary.total_contract_value:,.0f} |",
f"| 총 예산 | ${summary.total_budget:,.0f} |",
f"| 현재까지 실제 비용 | ${summary.total_actual_cost:,.0f} |",
f"| 완료 예상 비용 | ${summary.total_forecast_cost:,.0f} |",
"",
"## 성과 지표",
"",
f"| 지표 | 값 | 상태 |",
f"|--------|-------|------|",
f"| 평균 CPI | {summary.avg_cpi:.2f} | {'✅' if summary.avg_cpi >= 0.95 else '⚠️'} |",
f"| 평균 SPI | {summary.avg_spi:.2f} | {'✅' if summary.avg_spi >= 0.95 else '⚠️'} |",
f"| 예산 준수율 | {summary.on_budget_pct:.0f}% |",
f"| 일정 준수율 | {summary.on_schedule_pct:.0f}% |",
f"| 포트폴리오 TRIR | {summary.portfolio_trir:.1f} |",
"",
"## 상태 분포",
"",
f"- 🟢 정상: {summary.green_count}개 프로젝트",
f"- 🟡 위험: {summary.yellow_count}개 프로젝트",
f"- 🔴 심각: {summary.red_count}개 프로젝트",
"",
"## 트렌드",
"",
f"- 비용 추세: {summary.cost_trend}",
f"- 일정 추세: {summary.schedule_trend}",
"",
"---",
"*GENERATED: 자동 생성된 포트폴리오 요약*"
]
return "\n".join(lines)
# 사용 예시
if __name__ == "__main__":
import json
from datetime import datetime
# 포트폴리오 생성
dashboard = PortfolioDashboard(portfolio_name="본사 건설 프로젝트")
# CSV, API 또는 다른 소스에서 프로젝트 가져오기
from your_data_source import get_project_data
all_projects = get_project_data()
loaded = dashboard.import_projects(all_projects)
print(f"{loaded}개 프로젝트 로드 완료")
# 포트폴리오 요약 계산
summary = dashboard.calculate_portfolio_summary()
if summary:
print(f"평균 CPI: {summary.avg_cpi:.2f}")
print(f"예산 준수율: {summary.on_budget_pct:.0f}%")
# 위험 프로젝트 식별
at_risk = dashboard.get_projects_at_risk()
for project in at_risk:
print(f"⚠️ {project.project_name} - 상태: {project.health.value}")
# CPI 기준 비교
cpi_comparison = dashboard.compare_projects("cpi")
if cpi_comparison:
print(f"최고 성과: {cpi_comparison.best[0]} ({cpi_comparison.best[1]:.2f})")
print(f"최저 성과: {cpi_comparison.worst[0]} ({cpi_comparison.worst[1]:.2f})")
# 현금 흐름 예측
cash_forecast = dashboard.forecast_cash_needs(months=6)
for month in cash_forecast:
print(f"{month['month']}: ${month['projected_spend']:,.0f}")
# 보고서 생성
report = dashboard.generate_report()
print(report)
통합 가이드
데이터 소스
이 포트폴리오 대시보드는 다양한 소스의 데이터를 허용합니다:
| 소스 유형 | 형식 | 예시 |
|---|---|---|
| CSV 파일 | 구조화된 행 | 프로젝트 내보내기 |
| REST API | JSON 응답 | 프로젝트 관리 도구 |
| 데이터베이스 | SQL 쿼리 | ERP 시스템 |
| 맞춤형 | 사전 목록 | 레거시 시스템 |
필수 필드
{
"id": "PRJ-001",
"name": "리버사이드 타워",
"status": "active",
"contract_value": 50000000,
"planned_start": "2024-01-15",
"planned_end": "2026-06-30",
"budget": 45000000
}
선택적 필드
{
"actual_start": "2024-01-20",
"forecast_end": "2026-08-15",
"actual_cost": 12000000,
"forecast_cost": 47000000,
"percent_complete": 25,
"cpi": 0.92,
"spi": 0.88,
"incidents": 2,
"total_hours": 50000,
"risk_score": 6.5,
"critical_risks": 2
}
진행 단계
PortfolioDashboard인스턴스 생성import_projects()로 프로젝트 데이터 로드calculate_portfolio_summary()로 요약 생성generate_report()로 HTML/마크다운 보고서 출력- 정기적인
save_snapshot()으로 기간별 추세 추적 - 필요 시
get_projects_at_risk()로 개입 영역 식별
CLI 사용법
# 포트폴리오 요약 생성
python portfolio_dashboard.py --portfolio "본사 건설" --import data/projects.csv
# 위험 프로젝트 필터링
export RISK_THRESHOLD=7.0
python portfolio_dashboard.py --risk-report
# 보고서를 파일로 출력
python portfolio_dashboard.py --generate-report --output portfolio_report.md
환경 변수
| 변수 | 설명 | 기본값 |
|---|---|---|
PORTFOLIO_NAME | 포트폴리오 표시 이름 | "내 포트폴리오" |
DATA_FILE | 프로젝트 데이터 파일 경로 | "./projects.json" |
RISK_THRESHOLD | 위험 점수 임계값 | 7.0 |
OUTPUT_DIR | 보고서 출력 디렉토리 | "./reports" |
고급 기능
- 리소스 활용도 추적: 프로젝트 전반의 인력 및 장비 할당 모니터링
- 변경 관리 통합: 변경 요청이 프로젝트 예산 및 일정에 미치는 영향 추적
- 수익성 분석: 프로젝트 마진 및 포트폴리오 수익성 계산
- 가중 점수 모델: 맞춤형 점수 체계로 프로젝트 우선순위 지정
- 시나리오 분석: 포트폴리오 결과에 대한 가상 시나리오 모델링