portfolio-dashboard
Multi-project portfolio analytics dashboard. Aggregate KPIs across projects, track portfolio health, compare performance, and support executive decision-making.
Install / Use
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill portfolio-dashboardInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Data & AnalyticsSupported Platforms
Our assessment of portfolio-dashboard
portfolio-dashboard scores 91/100 on our quality scale, 264th of 599 Data & Analytics skills we index (top 45%).
Its SKILL.md is 18 KB long, well organised into 12 sections with 4 code examples: a thorough specification that gives an agent plenty to work with.
It has 333 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 3 months ago, so portfolio-dashboard is actively maintained.
- Our last check on 2026-11-20 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-07. Automated pattern scan on 2026-10-07. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
portfolio-dashboard compared with similar skills
All 4 of these similar skills score higher than portfolio-dashboard; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| portfolio-dashboard (this skill)by datadrivenconstruction | 91 | 333 | 3mo ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 113.3k | 12d ago | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 80.2k | today | CLAUDE.md |
| Scraplingby D4Vinci | 100 | 104.4k | 2d ago | MCP Server |
| crawl4aiby unclecode | 100 | 87.6k | today | MCP Server |
Frequently asked questions
- How do I install portfolio-dashboard?
- Run
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill portfolio-dashboard. The install tabs above show the steps for each supported agent. - Which AI agents does portfolio-dashboard work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is portfolio-dashboard safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is portfolio-dashboard still maintained?
- The repository was last updated about 3 months ago, so portfolio-dashboard is actively maintained.
Skill content
View source on GitHubname: "portfolio-dashboard" description: "Multi-project portfolio analytics dashboard. Aggregate KPIs across projects, track portfolio health, compare performance, and support executive decision-making." homepage: "https://datadrivenconstruction.io" metadata: {"openclaw": {"emoji": "🚀", "os": ["darwin", "linux", "win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
Portfolio Dashboard
Overview
Aggregate and analyze data across multiple construction projects for portfolio-level visibility. Track KPIs, identify trends, compare project performance, and support strategic resource allocation decisions.
Portfolio Analytics Framework
┌─────────────────────────────────────────────────────────────────┐
│ PORTFOLIO DASHBOARD │
├─────────────────────────────────────────────────────────────────┤
│ │
│ PROJECT A PROJECT B PROJECT C PROJECT D │
│ ↓ ↓ ↓ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ DATA AGGREGATION │ │
│ │ Cost | Schedule | Safety | Quality | Risk │ │
│ └─────────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────────┐ │
│ │ PORTFOLIO KPIs │ │
│ │ 📊 Total Value 📈 On-Schedule % │ │
│ │ 💰 On-Budget % 🛡️ Safety Rate │ │
│ │ ⚠️ Risk Score 📋 Resource Util │ │
│ └─────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
Technical Implementation
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" # On track
YELLOW = "yellow" # At risk
RED = "red" # Critical
GREY = "grey" # Not started/on hold
@dataclass
class ProjectMetrics:
project_id: str
project_name: str
status: ProjectStatus
contract_value: float
percent_complete: float
# Schedule
planned_start: datetime
planned_end: datetime
actual_start: Optional[datetime]
forecast_end: datetime
schedule_variance_days: int = 0
# Cost
budget: float
actual_cost: float
forecast_cost: float
cost_variance: float = 0.0
cpi: float = 1.0
spi: float = 1.0
# Safety
recordable_incidents: int = 0
total_hours: float = 0
trir: float = 0.0
# Quality
defects_open: int = 0
rework_cost: float = 0.0
# Risk
risk_score: float = 0.0
critical_risks: int = 0
@property
def health(self) -> HealthStatus:
"""Determine overall project health."""
if self.status in [ProjectStatus.ON_HOLD, ProjectStatus.CANCELLED]:
return HealthStatus.GREY
# Critical if significantly over budget/schedule
if self.cpi < 0.85 or self.spi < 0.85 or self.critical_risks > 3:
return HealthStatus.RED
# At risk if moderately off track
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
# Performance
avg_cpi: float
avg_spi: float
on_budget_pct: float
on_schedule_pct: float
# Safety
portfolio_trir: float
total_incidents: int
# Health distribution
green_count: int
yellow_count: int
red_count: int
# Trends
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-project portfolio analytics."""
# Health thresholds
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] = [] # Historical data
def add_project(self, metrics: ProjectMetrics):
"""Add or update project in portfolio."""
self.projects[metrics.project_id] = metrics
def import_projects(self, projects_data: List[Dict]) -> int:
"""Import multiple projects from data."""
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)
)
# Calculate derived metrics
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]:
"""Get list of active projects."""
return [p for p in self.projects.values()
if p.status == ProjectStatus.ACTIVE]
def calculate_portfolio_summary(self) -> PortfolioSummary:
"""Calculate portfolio-level summary metrics."""
active = self.get_active_projects()
all_projects = list(self.projects.values())
if not all_projects:
return None
# Totals
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)
# Performance averages (weighted by budget)
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/schedule percentages
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
# Safety metrics
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
# Health distribution
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])
# Trends (compare to previous snapshot if available)
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:
"""Compare projects by specific metric."""
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())
# Best/worst depends on metric (higher CPI good, lower TRIR good)
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]:
"""Get projects that need attention."""
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]:
"""Get top risks across portfolio."""
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"
Truncated for display — read the full file on GitHub.
Related Skills
Agent-Reach
113.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
headroom
80.2kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Scrapling
104.4k🕷️ The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev
crawl4ai
87.6kOfficial Crawl4AI Cloud: a hosted web scraping, extraction, and search API for AI agents. Free API key, 1,000 credits a month, no card. Fully open source: this repo is the Apache-2.0 crawler that powers it, and you can self-host it.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
