--- name: "senior-pm" description: Senior Project Manager for enterprise software, SaaS, and digital transformation projects. Specializes in portfolio management, quantitative risk analysis, resource optimization, stakeholder alignment, and executive reporting. Uses advanced methodologies including EMV analysis, Monte Carlo simulation, WSJF prioritization, and multi-dimensional health scoring. Use when a user needs help with project plans, project status reports, risk assessments, resource allocation, project roadmaps, milestone tracking, team capacity planning, portfolio health reviews, program management, or executive-level project reporting — especially for enterprise-scale initiatives with multiple workstreams, complex dependencies, or multi-million dollar budgets. --- # Senior Project Management Expert ## Overview Strategic project management for enterprise software, SaaS, and digital transformation initiatives. Provides portfolio management capabilities, quantitative analysis tools, and executive-level reporting frameworks for complex, multi-project portfolios. ### Core Expertise Areas **Portfolio Management & Strategic Alignment** - Multi-project portfolio optimization using advanced prioritization models (WSJF, RICE, ICE, MoSCoW) - Strategic roadmap development aligned with business objectives and market conditions - Resource capacity planning and allocation optimization across portfolio - Portfolio health monitoring with multi-dimensional scoring frameworks **Quantitative Risk Management** - Expected Monetary Value (EMV) analysis for financial risk quantification - Monte Carlo simulation for schedule risk modeling and confidence intervals - Risk appetite framework implementation with enterprise-level thresholds - Portfolio risk correlation analysis and diversification strategies **Executive Communication & Governance** - Board-ready executive reports with RAG status and strategic recommendations - Stakeholder alignment through sophisticated RACI matrices and escalation paths - Financial performance tracking with risk-adjusted ROI and NPV calculations - Change management strategies for large-scale digital transformations ## Methodology & Frameworks ### Three-Tier Analysis Approach **Tier 1: Portfolio Health Assessment** Uses `project_health_dashboard.py` to provide comprehensive multi-dimensional scoring: ```bash python3 scripts/project_health_dashboard.py assets/sample_project_data.json ``` **Health Dimensions (Weighted Scoring):** - **Timeline Performance** (25% weight): Schedule adherence, milestone achievement, critical path analysis - **Budget Management** (25% weight): Spend variance, forecast accuracy, cost efficiency metrics - **Scope Delivery** (20% weight): Feature completion rates, requirement satisfaction, change control - **Quality Metrics** (20% weight): Code coverage, defect density, technical debt, security posture - **Risk Exposure** (10% weight): Risk score, mitigation effectiveness, exposure trends **RAG Status Calculation:** - 🟢 Green: Composite score >80, all dimensions >60 - 🟡 Amber: Composite score 60-80, or any dimension 40-60 - 🔴 Red: Composite score <60, or any dimension <40 **Tier 2: Risk Matrix & Mitigation Strategy** Leverages `risk_matrix_analyzer.py` for quantitative risk assessment: ```bash python3 scripts/risk_matrix_analyzer.py assets/sample_project_data.json ``` **Risk Quantification Process:** 1. **Probability Assessment** (1-5 scale): Historical data, expert judgment, Monte Carlo inputs 2. **Impact Analysis** (1-5 scale): Financial, schedule, quality, and strategic impact vectors 3. **Category Weighting**: Technical (1.2x), Resource (1.1x), Financial (1.4x), Schedule (1.0x) 4. **EMV Calculation**: ```python # EMV and risk-adjusted budget calculation def calculate_emv(risks): category_weights = {"Technical": 1.2, "Resource": 1.1, "Financial": 1.4, "Schedule": 1.0} total_emv = 0 for risk in risks: score = risk["probability"] * risk["impact"] * category_weights[risk["category"]] emv = risk["probability"] * risk["financial_impact"] total_emv += emv risk["score"] = score return total_emv def risk_adjusted_budget(base_budget, portfolio_risk_score, risk_tolerance_factor): risk_premium = portfolio_risk_score * risk_tolerance_factor return base_budget * (1 + risk_premium) ``` **Risk Response Strategies (by score threshold):** - **Avoid** (>18): Eliminate through scope/approach changes - **Mitigate** (12-18): Reduce probability or impact through active intervention - **Transfer** (8-12): Insurance, contracts, partnerships - **Accept** (<8): Monitor with contingency planning **Tier 3: Resource Capacity Optimization** Employs `resource_capacity_planner.py` for portfolio resource analysis: ```bash python3 scripts/resource_capacity_planner.py assets/sample_project_data.json ``` **Capacity Analysis Framework:** - **Utilization Optimization**: Target 70-85% for sustainable productivity - **Skill Matching**: Algorithm-based resource allocation to maximize efficiency - **Bottleneck Identification**: Critical path resource constraints across portfolio - **Scenario Planning**: What-if analysis for resource reallocation strategies ### Advanced Prioritization Models Apply each model in the specific context where it provides the most signal: **Weighted Shortest Job First (WSJF)** — Resource-constrained agile portfolios with quantifiable cost-of-delay ```python def wsjf(user_value, time_criticality, risk_reduction, job_size): return (user_value + time_criticality + risk_reduction) / job_size ``` **RICE** — Customer-facing initiatives where reach metrics are quantifiable ```python def rice(reach, impact, confidence_pct, effort_person_months): return (reach * impact * (confidence_pct / 100)) / effort_person_months ``` **ICE** — Rapid prioritization during brainstorming or when analysis time is limited ```python def ice(impact, confidence, ease): return (impact + confidence + ease) / 3 ``` **Model Selection — Use this decision logic:** ``` if resource_constrained and agile_methodology and cost_of_delay_quantifiable: → WSJF elif customer_facing and reach_metrics_available: → RICE elif quick_prioritization_needed or ideation_phase: → ICE elif multiple_stakeholder_groups_with_differing_priorities: → MoSCoW elif complex_tradeoffs_across_incommensurable_criteria: → Multi-Criteria Decision Analysis (MCDA) ``` Reference: `references/portfolio-prioritization-models.md` ### Risk Management Framework Reference: `references/risk-management-framework.md` **Step 1: Risk Classification by Category** - Technical: Architecture, integration, performance - Resource: Availability, skills, retention - Schedule: Dependencies, critical path, external factors - Financial: Budget overruns, currency, economic factors - Business: Market changes, competitive pressure, strategic shifts **Step 2: Three-Point Estimation for Monte Carlo Inputs** ```python def three_point_estimate(optimistic, most_likely, pessimistic): expected = (optimistic + 4 * most_likely + pessimistic) / 6 std_dev = (pessimistic - optimistic) / 6 return expected, std_dev ``` **Step 3: Portfolio Risk Correlation** ```python import math def portfolio_risk(individual_risks, correlations): # individual_risks: list of risk EMV values # correlations: list of (i, j, corr_coefficient) tuples sum_sq = sum(r**2 for r in individual_risks) sum_corr = sum(2 * c * individual_risks[i] * individual_risks[j] for i, j, c in correlations) return math.sqrt(sum_sq + sum_corr) ``` **Risk Appetite Framework:** - **Conservative**: Risk scores 0-8, 25-30% contingency reserves - **Moderate**: Risk scores 8-15, 15-20% contingency reserves - **Aggressive**: Risk scores 15+, 10-15% contingency reserves ## Assets & Templates ### Project Charter Template Reference: `assets/project_charter_template.md` **Comprehensive 12-section charter including:** - Executive summary with strategic alignment - Success criteria with KPIs and quality gates - RACI matrix with decision authority levels - Risk assessment with mitigation strategies - Budget breakdown with contingency analysis - Timeline with critical path dependencies ### Executive Report Template Reference: `assets/executive_report_template.md` **Board-level portfolio reporting with:** - RAG status dashboard with trend analysis - Financial performance vs. strategic objectives - Risk heat map with mitigation status - Resource utilization and capacity analysis - Forward-looking recommendations with ROI projections ### RACI Matrix Template Reference: `assets/raci_matrix_template.md` **Enterprise-grade responsibility assignment featuring:** - Detailed stakeholder roster with decision authority - Phase-based RACI assignments (initiation through deployment) - Escalation paths with timeline and authority levels - Communication protocols and meeting frameworks - Conflict resolution processes with governance integration ### Sample Portfolio Data Reference: `assets/sample_project_data.json` **Realistic multi-project portfolio including:** - 4 projects across different phases and priorities - Complete financial data (budgets, actuals, forecasts) - Resource allocation with utilization metrics - Risk register with probability/impact scoring - Quality metrics and stakeholder satisfaction data - Dependencies and milestone tracking ### Expected Output Examples Reference: `assets/expected_output.json` **Demonstrates script capabilities with:** - Portfolio health scores and RAG status - Risk matrix visualization and mitigation priorities - Resource capacity analysis with optimization recommendations - Integration examples showing how outputs complement each other ## Implementation Workflows ### Portfolio Health Review (Weekly) 1. **Data Collection & Validation** ```bash python3 scripts/project_health_dashboard.py current_portfolio.json ``` ⚠️ If any project composite score <60 or a critical data field is missing, STOP and resolve data integrity issues before proceeding. 2. **Risk Assessment Update** ```bash python3 scripts/risk_matrix_analyzer.py current_portfolio.json ``` ⚠️ If any risk score >18 (Avoid threshold), STOP and initiate escalation to project sponsor before proceeding. 3. **Capacity Analysis** ```bash python3 scripts/resource_capacity_planner.py current_portfolio.json ``` ⚠️ If any team utilization >90% or <60%, flag for immediate reallocation discussion before step 4. 4. **Executive Summary Generation** - Synthesize outputs into executive report format - Highlight critical issues and recommendations - Prepare stakeholder communications ### Monthly Strategic Review 1. **Portfolio Prioritization Review** - Apply WSJF/RICE/ICE models to evaluate current priorities - Assess strategic alignment with business objectives - Identify optimization opportunities 2. **Risk Portfolio Analysis** - Update risk appetite and tolerance levels - Review portfolio risk correlation and concentration - Adjust risk mitigation investments 3. **Resource Optimization Planning** - Analyze capacity constraints across upcoming quarter - Plan resource reallocation and hiring strategies - Identify skill gaps and training needs 4. **Stakeholder Alignment Session** - Present portfolio health and strategic recommendations - Gather feedback on prioritization and resource allocation - Align on upcoming quarter priorities and investments ### Quarterly Portfolio Optimization 1. **Strategic Alignment Assessment** - Evaluate portfolio contribution to business objectives - Assess market and competitive position changes - Update strategic priorities and success criteria 2. **Financial Performance Review** - Analyze risk-adjusted ROI across portfolio - Review budget performance and forecast accuracy - Optimize investment allocation for maximum value 3. **Capability Gap Analysis** - Identify emerging technology and skill requirements - Plan capability building investments - Assess make vs. buy vs. partner decisions 4. **Portfolio Rebalancing** - Apply three horizons model for innovation balance - Optimize risk-return profile using efficient frontier - Plan new initiatives and sunset decisions ## Integration Strategies ### Atlassian Integration - **Jira**: Portfolio dashboards, cross-project metrics, risk tracking - **Confluence**: Strategic documentation, executive reports, knowledge management - Use MCP integrations to automate data collection and report generation ### Financial Systems Integration - **Budget Tracking**: Real-time spend data for variance analysis - **Resource Costing**: Hourly rates and utilization for capacity planning - **ROI Measurement**: Value realization tracking against projections ### Stakeholder Management - **Executive Dashboards**: Real-time portfolio health visualization - **Team Scorecards**: Individual project performance metrics - **Risk Registers**: Collaborative risk management with automated escalation ## Handoff Protocols ### TO Scrum Master **Context Transfer:** - Strategic priorities and success criteria - Resource allocation and team composition - Risk factors requiring sprint-level attention - Quality standards and acceptance criteria **Ongoing Collaboration:** - Weekly velocity and health metrics review - Sprint retrospective insights for portfolio learning - Impediment escalation and resolution support - Team capacity and utilization feedback ### TO Product Owner **Strategic Context:** - Market prioritization and competitive analysis - User value frameworks and measurement criteria - Feature prioritization aligned with portfolio objectives - Resource and timeline constraints **Decision Support:** - ROI analysis for feature investments - Risk assessment for product decisions - Market intelligence and customer feedback integration - Strategic roadmap alignment and dependencies ### FROM Executive Team **Strategic Direction:** - Business objective updates and priority changes - Budget allocation and resource approval decisions - Risk appetite and tolerance level adjustments - Market strategy and competitive response decisions **Performance Expectations:** - Portfolio health and value delivery targets - Timeline and milestone commitment expectations - Quality standards and compliance requirements - Stakeholder satisfaction and communication standards ## Success Metrics & KPIs Reference: `references/portfolio-kpis.md` for full definitions and measurement guidance. ### Portfolio Performance - On-time Delivery Rate: >80% within 10% of planned timeline - Budget Variance: <5% average across portfolio - Quality Score: >85 composite rating - Risk Mitigation Coverage: >90% risks with active plans - Resource Utilization: 75-85% average ### Strategic Value - ROI Achievement: >90% projects meeting projections within 12 months - Strategic Alignment: >95% investment aligned with business priorities - Innovation Balance: 70% operational / 20% growth / 10% transformational - Stakeholder Satisfaction: >8.5/10 executive average - Time-to-Value: <6 months average post-completion ### Risk Management - Risk Exposure: Maintain within approved appetite ranges - Resolution Time: <30 days (medium), <7 days (high) - Mitigation Cost Efficiency: <20% of total portfolio risk EMV - Risk Prediction Accuracy: >70% probability assessment accuracy ## Continuous Improvement Framework ### Portfolio Learning Integration - Capture lessons learned from completed projects - Update risk probability assessments based on historical data - Refine estimation accuracy through retrospective analysis - Share best practices across project teams ### Methodology Evolution - Regular review of prioritization model effectiveness - Update risk frameworks based on industry best practices - Integrate new tools and technologies for analysis efficiency - Benchmark against industry portfolio performance standards ### Stakeholder Feedback Integration - Quarterly stakeholder satisfaction surveys - Executive interview feedback on decision support quality - Team feedback on process efficiency and effectiveness - Customer impact assessment of portfolio decisions ## Related Skills - **Product Strategist** (`product-team/product-strategist/`) — Product OKRs align with portfolio objectives - **Scrum Master** (`project-management/scrum-master/`) — Sprint velocity data feeds project health dashboards FILE:assets/executive_report_template.md # Executive Portfolio Report Template **Reporting Period:** [Start Date] - [End Date] **Report Date:** [Report Generation Date] **Prepared By:** [Senior Project Manager Name] **Distribution:** Executive Leadership Team, Board of Directors --- ## Executive Summary & Key Messages ### Portfolio Health at a Glance - **Overall Portfolio Health:** 🟢 **GREEN** | 🟡 **AMBER** | 🔴 **RED** - **Total Active Projects:** [Number] projects, $[Total Budget]M investment - **Projects On-Track:** [Number]% | **At-Risk:** [Number]% | **Critical:** [Number]% - **This Quarter's Achievements:** [2-3 key wins with business impact] - **Critical Actions Needed:** [1-2 most urgent executive decisions required] ### Strategic Impact Summary | Strategic Priority | Progress | Risk Level | Business Value Delivered | |--------------------|----------|------------|--------------------------| | [Priority 1] | [%] Complete | 🟢🟡🔴 | $[Value]M / [Key Metric] | | [Priority 2] | [%] Complete | 🟢🟡🔴 | $[Value]M / [Key Metric] | | [Priority 3] | [%] Complete | 🟢🟡🔴 | $[Value]M / [Key Metric] | --- ## Portfolio Dashboard & RAG Status ### Current Portfolio Overview | Project Name | Priority | Status | Budget Health | Timeline | Risk Level | Business Value | |--------------|----------|---------|---------------|----------|------------|----------------| | [Project 1] | Critical | 🟢 | 📊 $[X]M / $[Y]M | [X]% | 🟢🟡🔴 | $[Value]M | | [Project 2] | High | 🟡 | 📊 $[X]M / $[Y]M | [X]% | 🟢🟡🔴 | $[Value]M | | [Project 3] | Medium | 🔴 | 📊 $[X]M / $[Y]M | [X]% | 🟢🟡🔴 | $[Value]M | ### RAG Status Definitions - 🟢 **GREEN:** On-track for all success criteria (scope, time, budget, quality) - 🟡 **AMBER:** Minor deviations, manageable with standard mitigation actions - 🔴 **RED:** Significant issues requiring immediate executive intervention ### Portfolio Trends (Last 6 Months) ``` 🟢 Green Projects: ████████░░ 75% → 80% (↗️ +5%) 🟡 Amber Projects: ████░░░░░░ 20% → 15% (↘️ -5%) 🔴 Red Projects: █░░░░░░░░░ 5% → 5% (→ No Change) ``` --- ## Financial Performance ### Budget Performance Summary | Metric | This Quarter | YTD | Variance | Forecast | |--------|--------------|-----|----------|----------| | **Total Portfolio Budget** | $[X]M | $[X]M | $[X]M ([±]%) | $[X]M | | **Actual Spend** | $[X]M | $[X]M | $[X]M ([±]%) | $[X]M | | **Committed/Forecast** | $[X]M | $[X]M | - | $[X]M | | **Available/Reserve** | $[X]M | $[X]M | - | $[X]M | ### Investment by Strategic Category ``` Digital Transformation: ████████████░ 60% ($[X]M) Operational Excellence: ████████░░░░░ 25% ($[X]M) Market Expansion: ████░░░░░░░░░ 15% ($[X]M) ``` ### ROI & Value Realization - **Expected Portfolio ROI:** [X]% over [Y] years - **Value Already Delivered:** $[X]M ([X]% of total expected value) - **At-Risk Value:** $[X]M (due to delayed/troubled projects) - **Value Acceleration Opportunities:** $[X]M (with additional investment) --- ## Key Achievements This Period ### Major Milestones Completed 1. **[Project Name] - [Milestone]** - **Business Impact:** [Quantified benefit - revenue, cost savings, efficiency] - **Strategic Value:** [How this advances business objectives] - **Stakeholder Impact:** [Customer, employee, operational improvements] 2. **[Project Name] - [Milestone]** - **Business Impact:** [Quantified benefit] - **Strategic Value:** [Strategic advancement] - **Stakeholder Impact:** [Stakeholder benefits] ### Business Value Delivered - **Revenue Impact:** $[X]M additional revenue / [X]% growth - **Cost Reduction:** $[X]M annual savings / [X]% efficiency gain - **Process Improvements:** [X]% faster processing / [X]% error reduction - **Customer Impact:** [X]% satisfaction increase / [X]K new customers - **Employee Impact:** [X]% productivity gain / [X] hours saved per week --- ## Critical Issues & Executive Decisions Needed ### 🔴 RED ALERT - Immediate Action Required #### Issue 1: [Critical Issue Title] - **Project:** [Project Name] - **Business Impact:** [Revenue at risk, customer impact, competitive disadvantage] - **Root Cause:** [Primary cause - resource, technical, external] - **Options Available:** 1. [Option 1]: [Cost, timeline, risk implications] 2. [Option 2]: [Cost, timeline, risk implications] 3. [Option 3]: [Cost, timeline, risk implications] - **Recommended Action:** [Clear recommendation with rationale] - **Decision Needed By:** [Date] - **Decision Maker:** [Executive Name/Role] ### 🟡 AMBER - Strategic Decisions Required #### Issue 2: [Strategic Issue Title] - **Context:** [Background and strategic importance] - **Decision Required:** [What needs to be decided and by when] - **Business Case:** [Financial and strategic implications] - **Recommendation:** [Proposed path forward] - **Dependencies:** [What else depends on this decision] ### Resource & Investment Requests | Request | Project | Justification | Investment Required | Expected ROI | Decision Date | |---------|---------|---------------|-------------------|--------------|---------------| | [Request 1] | [Project] | [Business case] | $[Amount] | [ROI/Value] | [Date] | | [Request 2] | [Project] | [Business case] | $[Amount] | [ROI/Value] | [Date] | --- ## Risk & Opportunity Management ### Top 5 Portfolio Risks | Risk | Probability | Business Impact | Mitigation Status | Owner | Action Required | |------|-------------|-----------------|-------------------|-------|-----------------| | [Risk 1] | [H/M/L] | $[X]M / [Strategic Impact] | 🟢🟡🔴 | [Owner] | [Action by Date] | | [Risk 2] | [H/M/L] | $[X]M / [Strategic Impact] | 🟢🟡🔴 | [Owner] | [Action by Date] | ### Emerging Opportunities 1. **[Opportunity Title]** - **Business Potential:** [Revenue potential, strategic advantage] - **Investment Required:** [Resources, budget, timeline] - **Decision Timeline:** [When decision needed] ### Risk Appetite & Tolerance - **Current Portfolio Risk Level:** [High/Medium/Low] vs Target [High/Medium/Low] - **Risk Concentration:** [Top risk categories and exposure levels] - **Mitigation Effectiveness:** [% of risks with active mitigation plans] --- ## Resource & Capacity Analysis ### Team Health & Capacity | Department | Utilization | Critical Resources | Capacity Alerts | |------------|-------------|-------------------|-----------------| | Engineering | [X]% | [Number] at >95% | 🟢🟡🔴 | | Product | [X]% | [Number] at >95% | 🟢🟡🔴 | | Design | [X]% | [Number] at >95% | 🟢🟡🔴 | ### Resource Conflicts & Bottlenecks - **Critical Resource Conflicts:** [Specific people/skills in high demand] - **Skill Gaps:** [Missing capabilities affecting multiple projects] - **Succession Risks:** [Key person dependencies and mitigation plans] ### Capacity Planning - **Current Quarter Capacity:** [X]% utilized - **Next Quarter Outlook:** [Capacity vs demand analysis] - **Resource Investment Needs:** [Where additional resources needed most] --- ## Market & Competitive Intelligence ### External Factors Impacting Portfolio - **Market Dynamics:** [Changes affecting project priorities or timelines] - **Competitive Moves:** [Competitor actions requiring portfolio adjustments] - **Regulatory Changes:** [Compliance requirements affecting projects] - **Technology Shifts:** [Emerging technologies creating opportunities/threats] ### Strategic Positioning - **Competitive Advantage Progress:** [How projects advance market position] - **Market Entry Status:** [New markets, customer segments being accessed] - **Innovation Pipeline:** [Next-generation capabilities being developed] --- ## Forward Look & Recommendations ### Next Quarter Priorities 1. **Priority 1:** [Specific focus area with success metrics] 2. **Priority 2:** [Specific focus area with success metrics] 3. **Priority 3:** [Specific focus area with success metrics] ### Strategic Recommendations 1. **[Recommendation 1]** - **Rationale:** [Why this is important now] - **Business Impact:** [Expected benefit] - **Investment Required:** [Resources, budget, timeline] - **Risk of Delay:** [Consequences of not acting] 2. **[Recommendation 2]** - [Same format as above] ### Portfolio Optimization Opportunities - **Resource Reallocation:** [Moving resources between projects for better ROI] - **Scope Adjustments:** [Projects where scope could be modified for faster value] - **Timeline Acceleration:** [Projects where additional investment could accelerate delivery] - **Strategic Pivots:** [Projects that should be redirected based on market changes] --- ## Key Performance Indicators ### Portfolio Health Metrics | KPI | This Period | Previous Period | YTD | Target | Trend | |-----|-------------|-----------------|-----|---------|-------| | **On-Time Delivery %** | [X]% | [X]% | [X]% | [X]% | ↗️↘️→ | | **Budget Variance %** | [±X]% | [±X]% | [±X]% | <[X]% | ↗️↘️→ | | **Quality Score** | [X]/10 | [X]/10 | [X]/10 | >[X] | ↗️↘️→ | | **Stakeholder Satisfaction** | [X]/10 | [X]/10 | [X]/10 | >[X] | ↗️↘️→ | | **ROI Achievement** | [X]% | [X]% | [X]% | [X]% | ↗️↘️→ | ### Business Impact Metrics | Metric | Current | Target | Gap | Notes | |--------|---------|---------|-----|-------| | **Revenue Impact** | $[X]M | $[X]M | $[X]M | [Commentary] | | **Cost Savings** | $[X]M | $[X]M | $[X]M | [Commentary] | | **Process Efficiency** | [X]% | [X]% | [X]% | [Commentary] | | **Customer Satisfaction** | [X]/10 | [X]/10 | [X] | [Commentary] | --- ## Appendix ### A. Detailed Project Status Reports [Link to individual project detailed reports] ### B. Financial Deep-Dive [Detailed budget analysis, variance explanations] ### C. Risk Register [Complete risk register with full details] ### D. Resource Allocation Matrix [Detailed resource assignments and utilization] ### E. Stakeholder Feedback Summary [Key feedback themes from stakeholder surveys/interviews] --- **Report Prepared By:** [Senior Project Manager Name] [Title] [Email] | [Phone] **Quality Assurance:** [PMO Director Name] - Reviewed and Approved [Date of Approval] **Next Report Due:** [Date] **Special Topics Next Period:** [Preview of upcoming focus areas] --- *This report contains confidential business information. Distribution limited to authorized executives only.* FILE:assets/expected_output.json { "description": "Expected outputs from all three senior-pm scripts when run against sample_project_data.json", "risk_matrix_analyzer": { "summary": { "total_risks": 6, "active_risks": 5, "closed_risks": 1, "critical_risks": 0, "high_risks": 1, "total_risk_exposure": 59.2, "average_risk_score": 11.84, "overdue_risks": 5 }, "risk_level_distribution": { "critical": 0, "high": 1, "medium": 3, "low": 1 }, "highest_risk_categories": [ "financial", "technical", "resource" ], "key_recommendations": [ "Focus mitigation efforts on financial risks - highest concentration of risk exposure", "Address overdue mitigation actions - more than 20% of risks are past their target resolution date" ], "top_risks": [ { "title": "Cloud migration budget overrun", "score": 16.8, "level": "high", "category": "financial" }, { "title": "Third-party API dependency for mobile banking app", "score": 14.4, "level": "medium", "category": "technical" }, { "title": "Key ML engineer departure risk", "score": 11.0, "level": "medium", "category": "resource" } ] }, "resource_capacity_planner": { "summary": { "total_resources": 6, "total_projects": 4, "active_projects": 2, "overall_utilization": 86.7 }, "utilization_analysis": { "optimal": 3, "over_utilized": 2, "critical": 1 }, "capacity_alerts": [ "CRITICAL: 1 resources are severely over-allocated (>95%)", "WARNING: 2 resources are over-allocated (85-95%)" ], "critical_resources": [ { "name": "Marcus Rodriguez", "role": "tech lead", "utilization": 100.0 } ], "available_capacity": { "Jennifer Walsh": "20% available (8h/week)", "Lisa Thompson": "30% available (12h/week)", "David Kim": "15% available (6h/week)" }, "key_recommendations": [ "URGENT: Redistribute workload for critically over-allocated resources to prevent burnout", "Review skill-to-project matching and consider reallocation for better efficiency" ] }, "project_health_dashboard": { "portfolio_overview": { "total_projects": 4, "active_projects": 3, "portfolio_average_score": 89.8, "projects_needing_attention": 0, "critical_projects": 0 }, "rag_status": { "green": 3, "amber": 0, "red": 0, "portfolio_grade": "healthy" }, "dimension_analysis": { "strongest": "timeline", "weakest": "quality", "dimension_scores": { "timeline": 100.0, "budget": 100.0, "scope": 100.0, "quality": 49.0, "risk": 100.0 } }, "project_performance": [ { "name": "Mobile Banking App v3.0", "score": 89.8, "status": "green", "priority": "high" }, { "name": "Cloud Infrastructure Migration", "score": 89.8, "status": "green", "priority": "critical" }, { "name": "AI-Powered Analytics Dashboard", "score": 89.8, "status": "green", "priority": "medium" } ], "key_recommendations": [ "Focus improvement efforts on quality - weakest portfolio dimension" ] }, "usage_examples": { "risk_analysis": { "command": "python3 scripts/risk_matrix_analyzer.py assets/sample_project_data.json", "description": "Generates comprehensive risk analysis with probability/impact matrix, category breakdown, and mitigation recommendations" }, "capacity_planning": { "command": "python3 scripts/resource_capacity_planner.py assets/sample_project_data.json", "description": "Analyzes resource utilization across portfolio, identifies capacity constraints and optimization opportunities" }, "portfolio_health": { "command": "python3 scripts/project_health_dashboard.py assets/sample_project_data.json", "description": "Provides executive dashboard view of portfolio health across multiple dimensions with RAG status" }, "json_output": { "command": "python3 scripts/[script_name].py assets/sample_project_data.json --format json", "description": "All scripts support JSON output format for integration with dashboards and reporting tools" } } } FILE:assets/project_charter_template.md # Project Charter Template **Project Name:** [Project Name] **Project ID:** [Unique Identifier] **Prepared By:** [Project Manager Name] **Date:** [Charter Date] **Version:** [Version Number] --- ## Executive Summary **One-sentence Project Description:** [Clear, concise statement of what the project will deliver and its primary value] **Strategic Alignment:** - Business Objective: [Link to specific business goal/OKR] - Strategic Priority: [High/Medium/Low with justification] - Portfolio Fit: [How this project fits within broader portfolio strategy] --- ## Project Definition ### Project Purpose & Business Case **Problem Statement:** [Clear articulation of the business problem or opportunity this project addresses] **Business Justification:** - Financial Impact: [ROI, NPV, cost savings, revenue impact] - Strategic Benefits: [Market position, competitive advantage, capability building] - Risk of NOT Doing: [Consequences of maintaining status quo] **Expected Business Value:** - Quantified Benefits: [Specific metrics and targets] - Qualitative Benefits: [Brand, customer satisfaction, employee engagement] - Success Metrics: [How success will be measured] ### Scope Definition **In Scope:** - [Specific deliverable 1 with acceptance criteria] - [Specific deliverable 2 with acceptance criteria] - [Specific deliverable 3 with acceptance criteria] **Out of Scope:** - [Explicitly excluded item 1 - prevents scope creep] - [Explicitly excluded item 2 - prevents scope creep] - [Future phases or features deferred] **Key Deliverables:** | Deliverable | Description | Acceptance Criteria | Due Date | |-------------|-------------|-------------------|----------| | [Name] | [Description] | [Measurable criteria] | [Date] | | [Name] | [Description] | [Measurable criteria] | [Date] | --- ## Success Criteria ### Primary Success Criteria 1. **[Criterion 1]:** [Specific, measurable outcome with target value] 2. **[Criterion 2]:** [Specific, measurable outcome with target value] 3. **[Criterion 3]:** [Specific, measurable outcome with target value] ### Key Performance Indicators (KPIs) | KPI | Baseline | Target | Measurement Method | Review Frequency | |-----|----------|--------|-------------------|------------------| | [KPI Name] | [Current State] | [Desired State] | [How Measured] | [When Reviewed] | ### Quality Gates - **Gate 1:** [Milestone] - [Quality criteria that must be met] - **Gate 2:** [Milestone] - [Quality criteria that must be met] - **Gate 3:** [Milestone] - [Quality criteria that must be met] --- ## Project Organization & RACI ### Steering Committee | Role | Name | Responsibilities | |------|------|-----------------| | Executive Sponsor | [Name] | Final accountability, funding authority, strategic alignment | | Business Owner | [Name] | Business requirements, user acceptance, benefits realization | | Technical Owner | [Name] | Technical architecture, standards compliance, technical risk | ### Core Project Team | Role | Name | RACI Key | Responsibilities | |------|------|----------|-----------------| | Project Manager | [Name] | A | Overall project delivery, timeline, budget, risk management | | Product Owner | [Name] | R | Requirements definition, backlog prioritization, user stories | | Technical Lead | [Name] | R | Technical design, code quality, technical decision-making | | QA Lead | [Name] | R | Test strategy, quality assurance, defect management | | UI/UX Designer | [Name] | R | User experience design, interface design, usability | ### Extended Stakeholders | Stakeholder Group | Representative | Interest Level | Influence Level | Communication Needs | |-------------------|----------------|----------------|-----------------|-------------------| | [Department/Group] | [Name] | [High/Medium/Low] | [High/Medium/Low] | [Frequency and method] | ### RACI Matrix - Key Decisions | Decision/Activity | Project Manager | Product Owner | Tech Lead | QA Lead | Sponsor | |-------------------|-----------------|---------------|-----------|---------|---------| | Requirements approval | A | R | C | C | I | | Technical architecture | A | C | R | C | I | | Go-live decision | A | C | C | C | R | | Scope changes | A | R | C | C | R | **RACI Legend:** R=Responsible, A=Accountable, C=Consulted, I=Informed --- ## Timeline & Milestones ### High-Level Timeline | Phase | Start Date | End Date | Key Deliverables | Dependencies | |-------|------------|----------|-----------------|--------------| | Discovery | [Date] | [Date] | Requirements, Architecture | [Dependencies] | | Development | [Date] | [Date] | Core Features, Testing | [Dependencies] | | Testing | [Date] | [Date] | QA Sign-off, UAT | [Dependencies] | | Deployment | [Date] | [Date] | Production Release | [Dependencies] | ### Critical Path Milestones 1. **[Milestone 1]:** [Date] - [Deliverable and significance] 2. **[Milestone 2]:** [Date] - [Deliverable and significance] 3. **[Milestone 3]:** [Date] - [Deliverable and significance] ### Dependencies & Constraints **External Dependencies:** - [Dependency 1]: [Description, owner, required date] - [Dependency 2]: [Description, owner, required date] **Resource Constraints:** - [Constraint 1]: [Description and mitigation plan] - [Constraint 2]: [Description and mitigation plan] --- ## Budget & Resources ### Budget Summary | Category | Planned Budget | Contingency | Total Authorized | |----------|----------------|-------------|------------------| | Personnel | $[Amount] | $[Amount] | $[Amount] | | Software/Licenses | $[Amount] | $[Amount] | $[Amount] | | Hardware/Infrastructure | $[Amount] | $[Amount] | $[Amount] | | External Services | $[Amount] | $[Amount] | $[Amount] | | **Total** | **$[Total]** | **$[Total]** | **$[Total]** | ### Resource Requirements | Role | FTE Required | Duration | Skills Required | Availability | |------|--------------|----------|----------------|--------------| | [Role] | [FTE] | [Months] | [Key Skills] | [Confirmed/TBD] | ### Funding & Financial Management - **Funding Source:** [Department/Budget code] - **Budget Authority:** [Who can approve expenditures] - **Financial Reporting:** [Frequency and format of budget reports] - **Change Control:** [Process for budget change requests] --- ## Risk Management ### High-Level Risk Assessment | Risk Category | Probability | Impact | Risk Score | Mitigation Strategy | |---------------|-------------|--------|------------|-------------------| | Technical | [H/M/L] | [H/M/L] | [1-25] | [High-level strategy] | | Resource | [H/M/L] | [H/M/L] | [1-25] | [High-level strategy] | | Schedule | [H/M/L] | [H/M/L] | [1-25] | [High-level strategy] | | Business | [H/M/L] | [H/M/L] | [1-25] | [High-level strategy] | ### Top 5 Project Risks 1. **[Risk Title]:** [Description, impact, probability, mitigation plan] 2. **[Risk Title]:** [Description, impact, probability, mitigation plan] 3. **[Risk Title]:** [Description, impact, probability, mitigation plan] 4. **[Risk Title]:** [Description, impact, probability, mitigation plan] 5. **[Risk Title]:** [Description, impact, probability, mitigation plan] ### Risk Management Process - **Risk Identification:** [How risks will be identified and by whom] - **Risk Assessment:** [Methodology for probability/impact scoring] - **Risk Response:** [Strategies - avoid, mitigate, transfer, accept] - **Risk Monitoring:** [Review frequency and reporting process] --- ## Communication & Governance ### Communication Plan | Audience | Information Needs | Format | Frequency | Owner | |----------|------------------|--------|-----------|-------| | Executive Sponsors | Status, risks, decisions needed | Dashboard + Meeting | Weekly | PM | | Steering Committee | Progress, issues, change requests | Report + Meeting | Bi-weekly | PM | | Project Team | Tasks, blockers, technical updates | Standup + Slack | Daily | Tech Lead | | Stakeholders | Feature progress, testing needs | Newsletter | Bi-weekly | PO | ### Decision-Making Framework - **Decision Types:** [Operational, tactical, strategic classifications] - **Decision Rights:** [Who makes what decisions at what levels] - **Escalation Path:** [When and how to escalate decisions upward] - **Decision Log:** [How decisions will be recorded and communicated] ### Change Control Process 1. **Change Request:** [How changes are requested and documented] 2. **Impact Assessment:** [Analysis of scope, time, cost, quality impacts] 3. **Approval Authority:** [Who can approve different types/sizes of changes] 4. **Implementation:** [How approved changes are implemented and communicated] --- ## Quality Management ### Quality Standards & Requirements - **Technical Standards:** [Coding standards, security requirements, performance criteria] - **Business Standards:** [Acceptance criteria, usability requirements, accessibility] - **Process Standards:** [Development methodology, testing approach, documentation] ### Quality Assurance Plan - **Code Reviews:** [Process, criteria, tools] - **Testing Strategy:** [Unit, integration, system, user acceptance testing] - **Quality Gates:** [Go/no-go criteria at each phase] - **Defect Management:** [Bug tracking, severity classification, resolution process] --- ## Assumptions & Constraints ### Key Assumptions - [Assumption 1 about resources, technology, or business environment] - [Assumption 2 about stakeholder availability or external dependencies] - [Assumption 3 about market conditions or regulatory environment] ### Project Constraints - **Time Constraints:** [Fixed deadlines, seasonal considerations] - **Budget Constraints:** [Funding limitations, cost restrictions] - **Resource Constraints:** [Team size limits, skill availability] - **Technical Constraints:** [System limitations, technology choices] - **Regulatory Constraints:** [Compliance requirements, approval processes] --- ## Approval & Sign-off ### Charter Approval | Role | Name | Signature | Date | |------|------|-----------|------| | Executive Sponsor | [Name] | _________________ | [Date] | | Business Owner | [Name] | _________________ | [Date] | | Project Manager | [Name] | _________________ | [Date] | | Technical Owner | [Name] | _________________ | [Date] | ### Project Authorization By signing this charter, the undersigned acknowledge they have reviewed and approve: - Project scope, objectives, and success criteria - Resource allocation and budget authorization - Timeline and milestone commitments - Risk acceptance and mitigation strategies - Communication and governance processes **Next Steps:** 1. Distribute approved charter to all stakeholders 2. Schedule project kick-off meeting 3. Begin detailed planning and team formation 4. Establish project tracking and reporting mechanisms --- **Document Control:** - **Template Version:** 2.1 - **Last Updated:** [Date] - **Next Review:** [Date] - **Document Owner:** Project Management Office FILE:assets/raci_matrix_template.md # RACI Matrix Template **Project:** [Project Name] **Version:** [Version Number] **Date:** [Creation/Update Date] **Owner:** [Project Manager Name] --- ## RACI Matrix Legend | Code | Role | Description | |------|------|-------------| | **R** | **Responsible** | The person(s) who actually performs the work to complete the task | | **A** | **Accountable** | The person who is ultimately answerable for the correct completion | | **C** | **Consulted** | The person(s) whose opinions are sought and with whom there is two-way communication | | **I** | **Informed** | The person(s) who are kept up-to-date on progress, often only one-way communication | ### RACI Best Practices - ✅ **One A per activity** - Only one person can be accountable for each task - ✅ **At least one R per activity** - Someone must be responsible for doing the work - ✅ **Minimize C's** - Too many consulted stakeholders can slow decision-making - ✅ **Strategic I's only** - Inform only those who truly need to know --- ## Stakeholder Roster ### Core Project Team | Name | Role | Department | Contact | Availability | |------|------|------------|---------|--------------| | [Name] | Project Manager | PMO | [email] | 100% | | [Name] | Product Owner | Product | [email] | 75% | | [Name] | Technical Lead | Engineering | [email] | 90% | | [Name] | UX Designer | Design | [email] | 50% | | [Name] | QA Lead | Quality | [email] | 60% | ### Executive Stakeholders | Name | Role | Department | Contact | Decision Authority | |------|------|------------|---------|-------------------| | [Name] | Executive Sponsor | [Department] | [email] | Budget & Strategic Direction | | [Name] | Business Owner | [Department] | [email] | Requirements & Acceptance | | [Name] | Technical Owner | [Department] | [email] | Architecture & Standards | ### Extended Stakeholders | Name | Role | Department | Contact | Interest Level | |------|------|------------|---------|----------------| | [Name] | [Role] | [Department] | [email] | High/Medium/Low | | [Name] | [Role] | [Department] | [email] | High/Medium/Low | --- ## Project Phase RACI Matrices ### Phase 1: Project Initiation & Planning | Activity | Project Manager | Executive Sponsor | Business Owner | Product Owner | Technical Lead | |----------|-----------------|-------------------|----------------|---------------|----------------| | **Business Case Development** | R | A | R | C | C | | **Project Charter Creation** | A, R | A | C | C | C | | **Stakeholder Analysis** | A, R | C | R | C | I | | **Initial Requirements Gathering** | A | I | R | R | C | | **High-Level Architecture** | A | I | C | C | R | | **Resource Planning** | A, R | A | C | C | C | | **Budget Approval** | R | A | C | I | I | | **Risk Assessment** | A, R | C | C | C | R | | **Project Charter Sign-off** | R | A | A | C | C | ### Phase 2: Design & Development Setup | Activity | Project Manager | Product Owner | Technical Lead | UX Designer | QA Lead | |----------|-----------------|---------------|----------------|-------------|---------| | **Requirements Documentation** | A | R | C | C | C | | **Technical Architecture** | A | C | R | I | C | | **System Design Documentation** | A | C | R | C | C | | **UI/UX Design** | A | R | C | R | I | | **Database Design** | A | I | R | I | C | | **API Specifications** | A | C | R | I | C | | **Test Strategy** | A | C | C | I | R | | **Development Environment Setup** | A | I | R | I | C | | **CI/CD Pipeline Setup** | A | I | R | I | R | ### Phase 3: Development & Implementation | Activity | Project Manager | Product Owner | Technical Lead | Dev Team | QA Lead | |----------|-----------------|---------------|----------------|----------|---------| | **Sprint Planning** | R | A | R | R | C | | **User Story Development** | A | R | C | C | C | | **Code Development** | A | C | R | R | I | | **Code Reviews** | I | I | A | R | I | | **Unit Testing** | I | I | R | R | C | | **Integration Testing** | A | C | R | R | R | | **Feature Testing** | A | R | C | I | R | | **Bug Triage** | R | A | R | R | R | | **Sprint Reviews** | A, R | R | R | R | R | ### Phase 4: Testing & Quality Assurance | Activity | Project Manager | Product Owner | Technical Lead | QA Lead | Business Owner | |----------|-----------------|---------------|----------------|---------|----------------| | **Test Plan Creation** | A | C | C | R | C | | **System Testing** | A | C | C | R | I | | **Performance Testing** | A | C | R | R | I | | **Security Testing** | A | I | R | R | I | | **User Acceptance Testing** | A | R | C | C | R | | **Bug Resolution** | A | C | R | R | I | | **Go-Live Readiness** | A | R | R | R | R | | **Sign-off Documentation** | R | R | C | R | A | ### Phase 5: Deployment & Launch | Activity | Project Manager | Technical Lead | DevOps | Business Owner | Support Team | |----------|-----------------|----------------|--------|----------------|--------------| | **Deployment Planning** | A | R | R | C | C | | **Production Deployment** | A | R | R | I | I | | **Smoke Testing** | A | R | C | C | R | | **Go-Live Communication** | R | C | I | A | I | | **User Training** | A | C | I | R | C | | **Support Documentation** | A | C | C | C | R | | **Monitoring Setup** | A | R | R | I | R | | **Launch Retrospective** | A, R | R | C | R | C | --- ## Decision-Making RACI ### Strategic Decisions | Decision Type | Project Manager | Executive Sponsor | Business Owner | Technical Owner | |---------------|-----------------|-------------------|----------------|-----------------| | **Budget Changes >10%** | R | A | C | C | | **Scope Changes (Major)** | R | A | R | C | | **Timeline Changes >2 weeks** | R | A | R | C | | **Technology Platform Changes** | R | C | C | A | | **Resource Reallocation** | A, R | A | C | C | | **Go/No-Go Decisions** | R | A | R | R | ### Operational Decisions | Decision Type | Project Manager | Product Owner | Technical Lead | Team Members | |---------------|-----------------|---------------|----------------|--------------| | **Sprint Scope** | C | A | R | R | | **Technical Implementation** | C | C | A, R | R | | **Bug Priority** | A | R | C | C | | **Code Standards** | C | C | A, R | R | | **Testing Approach** | A | C | R | R | | **Daily Task Assignment** | I | C | A | R | --- ## Escalation Paths & Conflict Resolution ### Escalation Matrix | Issue Level | Primary Resolver | Escalation To | Timeline | Authority | |-------------|------------------|---------------|----------|-----------| | **Level 1: Task/Technical** | Team Member → Technical Lead | Product Owner | 24 hours | Technical decisions | | **Level 2: Sprint/Feature** | Technical Lead → Product Owner | Project Manager | 48 hours | Feature scope/priority | | **Level 3: Project Impact** | Project Manager → Business Owner | Executive Sponsor | 72 hours | Budget/timeline changes | | **Level 4: Strategic** | Executive Sponsor → Steering Committee | CEO/Board | 1 week | Strategic direction | ### Conflict Resolution Process 1. **Direct Resolution** (Level 1) - **Who:** Conflicting parties attempt direct resolution - **Timeline:** 24 hours - **Documentation:** Brief note in project log 2. **Mediated Resolution** (Level 2) - **Who:** Project Manager facilitates discussion - **Timeline:** 48 hours from escalation - **Documentation:** Decision recorded with rationale 3. **Executive Resolution** (Level 3) - **Who:** Executive Sponsor makes binding decision - **Timeline:** 72 hours from escalation - **Documentation:** Formal decision memo to all stakeholders 4. **Steering Committee** (Level 4) - **Who:** Full steering committee vote - **Timeline:** Next scheduled meeting (max 1 week) - **Documentation:** Board resolution or meeting minutes ### Communication Protocols - **Escalation Notification:** All RACI stakeholders informed within 4 hours - **Decision Communication:** Decision communicated to all affected parties within 24 hours - **Documentation:** All escalations and resolutions logged in project management system --- ## Communication & Meeting RACI ### Regular Meetings | Meeting Type | Frequency | Project Manager | Team | Stakeholders | Sponsor | |-------------|-----------|-----------------|------|--------------|---------| | **Daily Standup** | Daily | A | R | I | I | | **Sprint Planning** | Bi-weekly | A | R | C | I | | **Sprint Review** | Bi-weekly | R | R | A | C | | **Stakeholder Updates** | Weekly | A, R | C | R | A | | **Steering Committee** | Monthly | R | I | C | A | ### Communication Artifacts | Artifact | Creator (R) | Approver (A) | Reviewers (C) | Recipients (I) | |----------|-------------|-------------|---------------|----------------| | **Status Reports** | Project Manager | Business Owner | Team Leads | All Stakeholders | | **Risk Register** | Project Manager | Executive Sponsor | Risk Owners | Steering Committee | | **Change Requests** | Requestor | Business Owner | Project Manager | Affected Teams | | **Decision Log** | Project Manager | Decision Maker | Consulted Parties | All Stakeholders | --- ## Risk & Issue Management RACI ### Risk Management | Activity | Project Manager | Risk Owner | Executive Sponsor | Team | |----------|-----------------|------------|-------------------|------| | **Risk Identification** | A | R | C | R | | **Risk Assessment** | A | R | C | C | | **Mitigation Planning** | A | R | C | R | | **Risk Monitoring** | A | R | I | C | | **Risk Escalation** | R | R | A | I | ### Issue Resolution | Issue Severity | Reporter (R) | Owner (A) | Resolver (R) | Informed (I) | |----------------|-------------|-----------|-------------|-------------| | **Critical** | Anyone | Project Manager | Technical Lead | Executive Sponsor | | **High** | Team/Stakeholder | Technical Lead | Team Member | Project Manager | | **Medium** | Team Member | Team Lead | Team Member | Project Manager | | **Low** | Team Member | Team Member | Team Member | Team Lead | --- ## RACI Validation & Maintenance ### Validation Checklist - [ ] Every activity has exactly one "A" (Accountable) - [ ] Every activity has at least one "R" (Responsible) - [ ] "C" (Consulted) roles are minimized to essential stakeholders - [ ] "I" (Informed) includes only those who truly need updates - [ ] No person is assigned "A" for more tasks than they can handle - [ ] Escalation paths are clear and realistic - [ ] Decision rights match organizational authority ### Review & Update Process - **Review Frequency:** Every project phase or monthly - **Update Triggers:** Team changes, scope changes, organizational changes - **Approval Process:** Changes require Project Manager and Executive Sponsor approval - **Communication:** RACI updates communicated to all stakeholders within 48 hours ### RACI Health Metrics | Metric | Target | Current | Notes | |--------|---------|---------|-------| | **Decision Speed** | <48 hours | [X] hours | Average time for routine decisions | | **Escalation Rate** | <10% | [X]% | Percentage of issues requiring escalation | | **Role Clarity** | >90% | [X]% | Stakeholder survey on role understanding | | **Conflict Resolution** | <72 hours | [X] hours | Average resolution time | --- **Document Control:** - **Version:** [Version Number] - **Last Updated:** [Date] - **Next Review:** [Date] - **Approved By:** [Executive Sponsor Name] **Distribution List:** - All Project Stakeholders (as identified in roster) - PMO (for template compliance) - HR (for role clarity and performance management) FILE:assets/sample_project_data.json { "portfolio_metadata": { "organization": "TechCorp Inc.", "reporting_period": "2025-Q1", "generated_on": "2025-02-15", "total_projects": 4, "total_budget": 2800000, "fte_count": 32 }, "projects": [ { "id": "PROJ001", "name": "Mobile Banking App v3.0", "status": "in_progress", "priority": "high", "start_date": "2024-10-01", "planned_end_date": "2025-06-30", "actual_end_date": null, "budget": { "planned": 850000, "spent": 425000, "remaining": 425000, "variance_percentage": 0.0 }, "timeline": { "total_sprints": 18, "completed_sprints": 9, "progress_percentage": 50.0, "days_behind_schedule": 5, "critical_path_delay": false }, "team": { "size": 12, "roles": { "product_manager": 1, "tech_lead": 1, "senior_developer": 3, "developer": 4, "qa_engineer": 2, "ui_ux_designer": 1 } }, "quality_metrics": { "code_coverage": 85.2, "test_pass_rate": 94.7, "defect_density": 0.8, "technical_debt_hours": 120, "security_vulnerabilities": 2 }, "stakeholder_satisfaction": 8.5, "scope_change_count": 3, "dependencies": ["PROJ002", "PROJ004"], "key_milestones": [ { "name": "MVP Release", "planned_date": "2025-03-15", "status": "at_risk", "completion_percentage": 75 }, { "name": "Beta Testing", "planned_date": "2025-05-01", "status": "on_track", "completion_percentage": 0 } ] }, { "id": "PROJ002", "name": "Cloud Infrastructure Migration", "status": "in_progress", "priority": "critical", "start_date": "2024-08-15", "planned_end_date": "2025-04-30", "actual_end_date": null, "budget": { "planned": 650000, "spent": 520000, "remaining": 130000, "variance_percentage": -20.0 }, "timeline": { "total_sprints": 16, "completed_sprints": 12, "progress_percentage": 75.0, "days_behind_schedule": 0, "critical_path_delay": false }, "team": { "size": 8, "roles": { "solution_architect": 1, "devops_engineer": 3, "senior_developer": 2, "security_specialist": 1, "project_manager": 1 } }, "quality_metrics": { "code_coverage": 78.9, "test_pass_rate": 98.2, "defect_density": 0.3, "technical_debt_hours": 45, "security_vulnerabilities": 0 }, "stakeholder_satisfaction": 9.2, "scope_change_count": 1, "dependencies": [], "key_milestones": [ { "name": "Phase 1: Core Services Migration", "planned_date": "2025-01-31", "status": "completed", "completion_percentage": 100 }, { "name": "Phase 2: Database Migration", "planned_date": "2025-03-15", "status": "on_track", "completion_percentage": 80 } ] }, { "id": "PROJ003", "name": "AI-Powered Analytics Dashboard", "status": "planning", "priority": "medium", "start_date": "2025-03-01", "planned_end_date": "2025-10-31", "actual_end_date": null, "budget": { "planned": 450000, "spent": 25000, "remaining": 425000, "variance_percentage": 0.0 }, "timeline": { "total_sprints": 16, "completed_sprints": 0, "progress_percentage": 5.0, "days_behind_schedule": 0, "critical_path_delay": false }, "team": { "size": 6, "roles": { "product_manager": 1, "ml_engineer": 2, "data_scientist": 1, "frontend_developer": 2 } }, "quality_metrics": { "code_coverage": 0.0, "test_pass_rate": 0.0, "defect_density": 0.0, "technical_debt_hours": 0, "security_vulnerabilities": 0 }, "stakeholder_satisfaction": 7.8, "scope_change_count": 0, "dependencies": ["PROJ002"], "key_milestones": [ { "name": "Data Pipeline Setup", "planned_date": "2025-04-30", "status": "not_started", "completion_percentage": 0 }, { "name": "ML Model Training", "planned_date": "2025-07-15", "status": "not_started", "completion_percentage": 0 } ] }, { "id": "PROJ004", "name": "Customer Portal Redesign", "status": "completed", "priority": "high", "start_date": "2024-05-01", "planned_end_date": "2024-12-15", "actual_end_date": "2024-12-22", "budget": { "planned": 320000, "spent": 340000, "remaining": 0, "variance_percentage": 6.25 }, "timeline": { "total_sprints": 14, "completed_sprints": 14, "progress_percentage": 100.0, "days_behind_schedule": 7, "critical_path_delay": true }, "team": { "size": 6, "roles": { "product_manager": 1, "ui_ux_designer": 2, "frontend_developer": 2, "qa_engineer": 1 } }, "quality_metrics": { "code_coverage": 92.4, "test_pass_rate": 99.1, "defect_density": 0.2, "technical_debt_hours": 18, "security_vulnerabilities": 0 }, "stakeholder_satisfaction": 9.5, "scope_change_count": 2, "dependencies": [], "key_milestones": [ { "name": "Design System Implementation", "planned_date": "2024-08-30", "status": "completed", "completion_percentage": 100 }, { "name": "User Acceptance Testing", "planned_date": "2024-11-30", "status": "completed", "completion_percentage": 100 } ] } ], "resources": [ { "id": "RES001", "name": "Sarah Chen", "role": "Senior Product Manager", "department": "Product", "hourly_rate": 120, "available_hours": 40, "current_utilization": 0.9, "skills": ["product_strategy", "stakeholder_management", "agile"], "current_projects": ["PROJ001", "PROJ003"], "capacity_notes": "Available for strategic initiatives" }, { "id": "RES002", "name": "Marcus Rodriguez", "role": "Tech Lead", "department": "Engineering", "hourly_rate": 110, "available_hours": 40, "current_utilization": 1.0, "skills": ["system_architecture", "team_leadership", "java", "microservices"], "current_projects": ["PROJ001"], "capacity_notes": "At full capacity, consider load balancing" }, { "id": "RES003", "name": "Jennifer Walsh", "role": "DevOps Engineer", "department": "Engineering", "hourly_rate": 105, "available_hours": 40, "current_utilization": 0.8, "skills": ["aws", "kubernetes", "terraform", "ci_cd"], "current_projects": ["PROJ002"], "capacity_notes": "Can take on additional infrastructure work" }, { "id": "RES004", "name": "David Kim", "role": "Senior Developer", "department": "Engineering", "hourly_rate": 95, "available_hours": 40, "current_utilization": 0.85, "skills": ["react", "node_js", "typescript", "aws"], "current_projects": ["PROJ001", "PROJ004"], "capacity_notes": "Strong full-stack capabilities" }, { "id": "RES005", "name": "Lisa Thompson", "role": "ML Engineer", "department": "Data Science", "hourly_rate": 115, "available_hours": 40, "current_utilization": 0.7, "skills": ["python", "tensorflow", "data_pipelines", "mlops"], "current_projects": ["PROJ003"], "capacity_notes": "Available for additional ML initiatives" }, { "id": "RES006", "name": "Ahmed Hassan", "role": "Solution Architect", "department": "Engineering", "hourly_rate": 125, "available_hours": 40, "current_utilization": 0.95, "skills": ["enterprise_architecture", "cloud_strategy", "security"], "current_projects": ["PROJ002"], "capacity_notes": "Critical resource for architectural decisions" } ], "risks": [ { "id": "RISK001", "title": "Third-party API dependency for mobile banking app", "description": "Banking app relies on external payment processor API that has had recent stability issues", "category": "technical", "probability": 3, "impact": 4, "status": "open", "owner": "Marcus Rodriguez", "project_id": "PROJ001", "created_date": "2024-11-15", "target_resolution": "2025-03-01", "mitigation_actions": [ "Implement fallback payment processor integration", "Add circuit breaker pattern for API calls", "Negotiate SLA improvements with vendor" ], "impact_areas": ["schedule", "quality", "customer_satisfaction"], "severity": "high" }, { "id": "RISK002", "title": "Cloud migration budget overrun", "description": "Migration costs exceeding budget due to unexpected data transfer fees and extended downtime windows", "category": "financial", "probability": 4, "impact": 3, "status": "open", "owner": "Jennifer Walsh", "project_id": "PROJ002", "created_date": "2024-12-01", "target_resolution": "2025-02-28", "mitigation_actions": [ "Implement incremental data migration strategy", "Negotiate volume discounts with cloud provider", "Optimize data transfer timing for cost efficiency" ], "impact_areas": ["budget", "timeline"], "severity": "high" }, { "id": "RISK003", "title": "Key ML engineer departure risk", "description": "Primary ML engineer considering external opportunity, critical for AI dashboard project", "category": "resource", "probability": 2, "impact": 5, "status": "open", "owner": "Sarah Chen", "project_id": "PROJ003", "created_date": "2025-01-10", "target_resolution": "2025-03-31", "mitigation_actions": [ "Conduct retention conversation and career planning", "Cross-train additional team members on ML pipeline", "Identify external consultant as backup resource" ], "impact_areas": ["timeline", "quality", "team_morale"], "severity": "critical" }, { "id": "RISK004", "title": "Regulatory compliance requirements for banking app", "description": "New financial regulations may require additional security features and audit trails", "category": "compliance", "probability": 3, "impact": 3, "status": "open", "owner": "Ahmed Hassan", "project_id": "PROJ001", "created_date": "2024-12-15", "target_resolution": "2025-04-30", "mitigation_actions": [ "Engage legal and compliance teams early", "Build regulatory requirements into technical design", "Plan for additional security audit phase" ], "impact_areas": ["timeline", "scope", "budget"], "severity": "medium" }, { "id": "RISK005", "title": "Integration complexity with legacy systems", "description": "Cloud migration may face unexpected integration challenges with legacy on-premise systems", "category": "technical", "probability": 2, "impact": 2, "status": "mitigated", "owner": "Ahmed Hassan", "project_id": "PROJ002", "created_date": "2024-09-01", "target_resolution": "2024-12-31", "mitigation_actions": [ "Complete comprehensive system mapping and API inventory", "Create detailed integration test suite", "Establish rollback procedures for each integration phase" ], "impact_areas": ["timeline", "quality"], "severity": "low" }, { "id": "RISK006", "title": "Data privacy requirements for analytics platform", "description": "AI dashboard must comply with GDPR and CCPA for customer data analysis", "category": "compliance", "probability": 4, "impact": 2, "status": "open", "owner": "Lisa Thompson", "project_id": "PROJ003", "created_date": "2025-02-01", "target_resolution": "2025-05-15", "mitigation_actions": [ "Implement data anonymization in ML pipeline", "Add consent management features to data collection", "Conduct privacy impact assessment" ], "impact_areas": ["timeline", "scope"], "severity": "medium" } ], "historical_data": { "risk_trends": { "2024-Q3": { "total_risks": 3, "average_score": 8.5, "critical_risks": 1 }, "2024-Q4": { "total_risks": 5, "average_score": 10.2, "critical_risks": 1 }, "2025-Q1": { "total_risks": 6, "average_score": 9.8, "critical_risks": 1 } }, "resource_utilization": { "2024-Q4": 0.87, "2025-Q1": 0.89 }, "project_delivery": { "on_time_percentage": 0.75, "budget_variance_avg": 0.05 } } } FILE:references/portfolio-kpis.md # Portfolio KPIs Reference ## Delivery KPIs | KPI | Formula | Target | |-----|---------|--------| | Sprint Velocity | Story points completed / sprint | Stable ±10% | | Sprint Predictability | Completed / Committed × 100 | ≥80% | | Cycle Time | Time from In Progress → Done | Decreasing trend | | Lead Time | Time from Created → Done | <2 sprints | | Throughput | Items completed per sprint | Increasing trend | ## Quality KPIs | KPI | Formula | Target | |-----|---------|--------| | Defect Escape Rate | Prod bugs / total stories × 100 | <5% | | Rework Rate | Reopened items / completed × 100 | <10% | | Test Coverage | Covered lines / total lines × 100 | >80% | ## Team Health KPIs | KPI | Formula | Target | |-----|---------|--------| | Planned vs Unplanned | Unplanned work / total work × 100 | <20% | | Blocked Time | Hours blocked / total hours × 100 | <10% | | WIP Limit Compliance | Times WIP exceeded / sprints × 100 | <15% | ## Portfolio KPIs | KPI | Formula | Target | |-----|---------|--------| | On-Time Delivery | Projects on schedule / total | >85% | | Budget Variance | (Actual - Budget) / Budget × 100 | ±10% | | Resource Utilization | Allocated / Available × 100 | 70-85% | | Strategic Alignment | Projects aligned to OKRs / total | >80% | FILE:references/portfolio-prioritization-models.md # Portfolio Prioritization Models & Decision Frameworks ## Executive Overview This reference guide provides senior project managers with sophisticated prioritization methodologies for managing complex project portfolios. It covers quantitative scoring models (WSJF, ICE, RICE), qualitative frameworks (MoSCoW, Kano), and decision trees for selecting the optimal prioritization approach based on context, stakeholder needs, and strategic objectives. --- ## Model Selection Decision Tree ### Context-Based Framework Selection ``` START: What is your primary prioritization objective? ├── Maximize Business Value & ROI │ ├── Clear quantitative metrics available? → RICE Model │ └── Mix of quantitative/qualitative factors? → Weighted Scoring Matrix │ ├── Optimize Resource Utilization │ ├── Agile/SAFe environment? → WSJF (Weighted Shortest Job First) │ └── Traditional PM environment? → Resource-Constraint Optimization │ ├── Stakeholder Alignment & Buy-in │ ├── Multiple stakeholder groups? → MoSCoW Method │ └── Customer-focused prioritization? → Kano Analysis │ ├── Speed of Decision Making │ ├── Need rapid decisions? → ICE Scoring │ └── Complex trade-offs acceptable? → Multi-Criteria Decision Analysis │ └── Strategic Portfolio Balance ├── Innovation vs. Operations balance? → Three Horizons Model └── Risk vs. Return optimization? → Efficient Frontier Analysis ``` --- ## Quantitative Prioritization Models ### 1. WSJF (Weighted Shortest Job First) **Best Used For:** Agile portfolios, resource-constrained environments, when cost of delay is critical **Formula:** `WSJF Score = (User/Business Value + Time Criticality + Risk Reduction) ÷ Job Size` #### Detailed Scoring Framework **User/Business Value (1-20 scale):** - **1-5:** Nice to have improvements, minimal user impact - **6-10:** Moderate value, affects subset of users/processes - **11-15:** Significant value, major user/business impact - **16-20:** Critical value, transformational business impact **Time Criticality (1-20 scale):** - **1-5:** No time pressure, can be delayed 12+ months - **6-10:** Some urgency, should complete within 6-12 months - **11-15:** Urgent, needed within 3-6 months - **16-20:** Critical time pressure, needed within 1-3 months **Risk Reduction/Opportunity Enablement (1-20 scale):** - **1-5:** Minimal risk mitigation or future opportunity impact - **6-10:** Moderate risk reduction or enables some future work - **11-15:** Significant risk mitigation or enables key capabilities - **16-20:** Critical risk mitigation or foundational for future strategy **Job Size (1-20 scale, reverse scored):** - **1-5:** Very large (>12 months, >$2M, >20 people) - **6-10:** Large (6-12 months, $1-2M, 10-20 people) - **11-15:** Medium (3-6 months, $500K-1M, 5-10 people) - **16-20:** Small (<3 months, <$500K, <5 people) #### WSJF Implementation Example ``` Project A: Mobile App Enhancement - User Value: 15 (significant user experience improvement) - Time Criticality: 12 (competitive pressure, 4-month window) - Risk Reduction: 8 (moderate technical debt reduction) - Job Size: 14 (3-month project, $750K, 7 people) WSJF = (15 + 12 + 8) ÷ 14 = 2.5 Project B: Infrastructure Security Upgrade - User Value: 8 (minimal user-facing impact) - Time Criticality: 18 (regulatory compliance deadline) - Risk Reduction: 17 (critical security vulnerability mitigation) - Job Size: 10 (8-month project, $1.5M, 12 people) WSJF = (8 + 18 + 17) ÷ 10 = 4.3 Result: Project B prioritized despite lower user value due to criticality and risk reduction. ``` ### 2. RICE Framework **Best Used For:** Product development, marketing initiatives, when reach and impact can be quantified **Formula:** `RICE Score = (Reach × Impact × Confidence) ÷ Effort` #### RICE Scoring Guidelines **Reach (Number per time period):** - **Projects:** Number of users/customers/processes affected per month - **Internal Initiatives:** Number of employees/systems/workflows impacted - **Strategic Programs:** Market size or business units affected **Impact (Multiplier scale):** - **3.0:** Massive impact - Transforms core business metrics - **2.0:** High impact - Significantly improves key metrics - **1.0:** Medium impact - Moderately improves metrics - **0.5:** Low impact - Slight improvement in metrics - **0.25:** Minimal impact - Barely measurable improvement **Confidence (Percentage as decimal):** - **100% (1.0):** High confidence - Strong data and precedent - **80% (0.8):** Medium confidence - Some data, reasonable assumptions - **50% (0.5):** Low confidence - Limited data, high uncertainty **Effort (Person-months):** - Total estimated effort across all teams and functions - Include planning, design, development, testing, deployment, training #### RICE Application Example ``` Initiative: Customer Self-Service Portal - Reach: 50,000 customers per month - Impact: 1.0 (moderate reduction in support calls) - Confidence: 0.8 (good data from customer surveys) - Effort: 18 person-months RICE = (50,000 × 1.0 × 0.8) ÷ 18 = 2,222 Initiative: Sales Process Automation - Reach: 200 sales reps per month - Impact: 2.0 (significant productivity improvement) - Confidence: 0.9 (pilot data available) - Effort: 12 person-months RICE = (200 × 2.0 × 0.9) ÷ 12 = 30 Result: Sales automation prioritized despite much smaller reach due to high impact and efficiency. ``` ### 3. ICE Scoring **Best Used For:** Rapid prioritization, brainstorming sessions, when detailed analysis isn't feasible **Formula:** `ICE Score = (Impact + Confidence + Ease) ÷ 3` Each dimension scored 1-10: **Impact (1-10):** - **10:** Revolutionary change, massive business impact - **7-9:** Significant improvement in key metrics - **4-6:** Moderate positive impact - **1-3:** Minimal or unclear impact **Confidence (1-10):** - **10:** Certain of outcome, strong data/precedent - **7-9:** High confidence, some supporting evidence - **4-6:** Medium confidence, reasonable assumptions - **1-3:** Low confidence, uncertain outcome **Ease (1-10):** - **10:** Minimal effort, existing resources, low complexity - **7-9:** Moderate effort, some new resources needed - **4-6:** Significant effort, substantial resource commitment - **1-3:** Very difficult, major resource investment #### ICE Prioritization Matrix | Initiative | Impact | Confidence | Ease | ICE Score | Priority | |------------|--------|------------|------|-----------|----------| | API Documentation Update | 6 | 9 | 9 | 8.0 | High | | Machine Learning Platform | 9 | 5 | 3 | 5.7 | Medium | | Mobile App Redesign | 8 | 7 | 5 | 6.7 | Medium-High | | Data Warehouse Migration | 7 | 8 | 2 | 5.7 | Medium | --- ## Qualitative Prioritization Frameworks ### 1. MoSCoW Method **Best Used For:** Scope management, stakeholder alignment, requirement prioritization **Categories:** - **Must Have:** Non-negotiable requirements, project fails without these - **Should Have:** Important but not critical, can be delayed if necessary - **Could Have:** Nice to have, include if resources permit - **Won't Have:** Explicitly out of scope for current timeframe #### MoSCoW Implementation Guidelines **Must Have Criteria:** - Legal/regulatory requirement - Critical business process dependency - Fundamental system functionality - Security/compliance necessity **Should Have Criteria:** - Significant user value or business benefit - Competitive advantage requirement - Important process improvement - Strong stakeholder demand **Could Have Criteria:** - Enhancement to user experience - Process optimization opportunity - Future-proofing consideration - Secondary stakeholder request **Won't Have Criteria:** - Feature creep identification - Future phase consideration - Out-of-budget items - Low-value/high-effort items #### MoSCoW with Quantitative Overlay ``` Priority Distribution Guidelines: - Must Have: 60% of budget/effort (ensures core delivery) - Should Have: 20% of budget/effort (key value delivery) - Could Have: 20% of budget/effort (buffer for scope adjustment) - Won't Have: Document for future consideration Risk Management: - If Must Haves exceed 60%: Scope too large, requires reduction - If Should Haves exceed 30%: Risk of scope creep - If Could Haves exceed 20%: May indicate unclear priorities ``` ### 2. Kano Model Analysis **Best Used For:** Customer-focused prioritization, product development, user experience improvements #### Kano Categories **Basic Needs (Must-Be):** - **Definition:** Expected features, dissatisfaction if absent - **Customer Response:** "Of course it should do that" - **Business Impact:** Prevents customer loss but doesn't drive acquisition - **Examples:** Security, basic functionality, compliance **Performance Needs (More-Is-Better):** - **Definition:** Linear satisfaction relationship with performance - **Customer Response:** "The better it performs, the happier I am" - **Business Impact:** Competitive differentiation opportunity - **Examples:** Speed, efficiency, cost, reliability **Excitement Needs (Delighters):** - **Definition:** Unexpected features that create delight - **Customer Response:** "Wow, I didn't expect that!" - **Business Impact:** Customer acquisition and loyalty driver - **Examples:** Innovative features, exceptional experiences **Indifferent Features:** - **Definition:** Features customers don't care about - **Customer Response:** "Whatever, doesn't matter to me" - **Business Impact:** Resource waste if prioritized - **Action:** Eliminate or deprioritize **Reverse Features:** - **Definition:** Features that actually create dissatisfaction - **Customer Response:** "I wish this wasn't here" - **Business Impact:** Customer churn risk - **Action:** Remove immediately #### Kano Prioritization Matrix | Feature | Kano Category | Customer Impact | Implementation Cost | Priority Score | |---------|---------------|-----------------|-------------------|----------------| | Single Sign-On | Basic | High Dissatisfaction if Missing | Medium | Must Do | | Load Time <2sec | Performance | Linear Satisfaction | High | High Priority | | AI-Powered Recommendations | Excitement | High Delight Potential | Very High | Medium Priority | | Advanced Analytics Dashboard | Indifferent | Low Interest | Medium | Low Priority | --- ## Advanced Prioritization Models ### 1. Multi-Criteria Decision Analysis (MCDA) **Best Used For:** Complex portfolios with multiple competing objectives and diverse stakeholder interests #### Weighted Scoring Matrix Setup **Step 1: Define Evaluation Criteria** ``` Strategic Criteria (40% weight): - Strategic Alignment (15%) - Market Opportunity (10%) - Competitive Advantage (15%) Financial Criteria (35% weight): - ROI/NPV (20%) - Payback Period (10%) - Cost Efficiency (5%) Risk/Feasibility Criteria (25% weight): - Technical Risk (10%) - Resource Availability (10%) - Timeline Feasibility (5%) ``` **Step 2: Score Each Project (1-5 scale)** **Step 3: Calculate Weighted Scores** ``` Project Score = Σ(Criterion Score × Criterion Weight) Example: Project Alpha: - Strategic Alignment: 4 × 0.15 = 0.60 - Market Opportunity: 5 × 0.10 = 0.50 - Competitive Advantage: 3 × 0.15 = 0.45 - ROI/NPV: 4 × 0.20 = 0.80 - Payback Period: 3 × 0.10 = 0.30 - Cost Efficiency: 5 × 0.05 = 0.25 - Technical Risk: 2 × 0.10 = 0.20 - Resource Availability: 4 × 0.10 = 0.40 - Timeline Feasibility: 4 × 0.05 = 0.20 Total Score: 3.70 ``` ### 2. Three Horizons Model **Best Used For:** Balancing innovation with operational excellence, strategic portfolio planning #### Horizon Definitions **Horizon 1: Core Business (70% of portfolio)** - **Focus:** Optimize existing products/services - **Timeline:** 0-2 years - **Risk Level:** Low - **ROI Expectation:** High certainty, moderate returns - **Examples:** Process improvements, maintenance, incremental features **Horizon 2: Emerging Opportunities (20% of portfolio)** - **Focus:** Extend core capabilities into new areas - **Timeline:** 2-5 years - **Risk Level:** Medium - **ROI Expectation:** Medium certainty, high returns - **Examples:** New markets, adjacent products, platform extensions **Horizon 3: Transformational Initiatives (10% of portfolio)** - **Focus:** Create new capabilities and business models - **Timeline:** 5+ years - **Risk Level:** High - **ROI Expectation:** Low certainty, very high potential returns - **Examples:** Breakthrough technologies, new business models, moonshots #### Portfolio Balance Guidelines ``` Balanced Portfolio Allocation: - Conservative Organization: H1=80%, H2=15%, H3=5% - Growth-Oriented: H1=60%, H2=25%, H3=15% - Innovation Leader: H1=50%, H2=30%, H3=20% Risk Management: - H1 projects should fund H2 and H3 experiments - H2 successes should scale to become new H1 businesses - H3 failures should generate learning for future initiatives ``` ### 3. Efficient Frontier Analysis **Best Used For:** Risk-return optimization, portfolio-level resource allocation #### Risk-Return Plotting **Step 1: Quantify Risk and Return for Each Project** ``` Return Metrics: - Expected NPV or IRR - Strategic value score - Market opportunity size Risk Metrics: - Probability of failure - Variance in expected outcomes - Technical/market uncertainty ``` **Step 2: Plot Projects on Risk-Return Matrix** **Step 3: Identify Efficient Frontier** - Projects offering maximum return for each risk level - Projects below the frontier are suboptimal - Portfolio optimization involves selecting mix along frontier **Step 4: Apply Risk Appetite** - Conservative: Lower risk portion of frontier - Moderate: Balanced mix across frontier - Aggressive: Higher risk/return portion #### Portfolio Optimization Example ``` Efficient Frontier Projects: - Low Risk/Low Return: Process Automation (Risk=2, Return=15%) - Medium Risk/Medium Return: Market Expansion (Risk=5, Return=25%) - High Risk/High Return: New Technology Platform (Risk=8, Return=45%) Suboptimal Projects: - High Risk/Low Return: Legacy System Upgrade (Risk=7, Return=12%) - Reason: Market Expansion offers better return for similar risk level ``` --- ## Decision Trees for Model Selection ### Scenario-Based Model Selection #### Scenario 1: Resource-Constrained Environment ``` Available Resources < Demand? ├── Yes: Use WSJF (maximize value per unit effort) └── No: Use RICE or Weighted Scoring (optimize for maximum impact) Time Pressure for Decisions? ├── High: Use ICE Scoring (rapid evaluation) └── Low: Use MCDA (thorough analysis) Stakeholder Alignment Issues? ├── Yes: Use MoSCoW (consensus building) └── No: Proceed with quantitative method ``` #### Scenario 2: Innovation vs. Operations Balance ``` Portfolio Currently Imbalanced? ├── Too Operational: Apply Three Horizons Model (increase H2/H3) ├── Too Innovative: Focus on H1 projects (stabilize revenue) └── Balanced: Use efficient frontier analysis (optimize mix) Strategic Direction Clear? ├── Yes: Use strategic alignment scoring └── No: Use broad stakeholder input (MoSCoW or Kano) ``` #### Scenario 3: Customer vs. Business Value Tension ``` Primary Value Driver? ├── Customer Satisfaction: Use Kano Analysis ├── Business ROI: Use RICE or financial scoring └── Both Equally Important: Use balanced scorecard approach Data Availability? ├── Rich Customer Data: Kano → RICE combination ├── Limited Data: ICE scoring → MoSCoW validation └── Financial Data Only: WSJF or NPV ranking ``` --- ## Hybrid Prioritization Approaches ### 1. Two-Stage Prioritization **Stage 1: Strategic Filtering** - Apply MoSCoW or Strategic Alignment Filter - Eliminate projects that don't meet minimum criteria - Reduce candidate pool by 40-60% **Stage 2: Detailed Scoring** - Apply WSJF, RICE, or MCDA to remaining candidates - Rank order for resource allocation - Final prioritization with stakeholder review ### 2. Weighted Multi-Model Approach ``` Combined Score = (WSJF Score × 0.4) + (Strategic Score × 0.3) + (Risk Score × 0.3) Benefits: - Reduces single-model bias - Incorporates multiple perspectives - Provides robustness check Challenges: - More complex to calculate - Requires normalization of scales - May obscure clear trade-offs ``` ### 3. Dynamic Prioritization **Concept:** Priorities change as conditions change; build flexibility into the system **Implementation:** - Monthly priority reviews using lightweight scoring (ICE) - Quarterly deep-dive analysis using comprehensive model (MCDA) - Annual strategic realignment using Three Horizons **Trigger Events for Reprioritization:** - Significant market changes - Technology breakthroughs or failures - Resource availability changes - Strategic direction shifts - Competitive moves --- ## Implementation Best Practices ### 1. Model Calibration and Validation **Historical Validation:** - Compare model predictions to actual project outcomes - Identify systematic biases in scoring - Adjust scoring criteria based on lessons learned **Cross-Validation:** - Use multiple models on same project set - Investigate projects that rank very differently - Understand root causes of ranking differences **Stakeholder Validation:** - Present prioritization results to key stakeholders - Gather feedback on "surprising" rankings - Adjust weights or criteria based on strategic input ### 2. Common Implementation Pitfalls **Over-Engineering the Process:** - **Problem:** Complex models that take too long to use - **Solution:** Start simple, add complexity only when needed **Score Inflation:** - **Problem:** All projects rated as high importance - **Solution:** Forced ranking, relative scoring, external calibration **Gaming the System:** - **Problem:** Project sponsors inflate scores to get priority - **Solution:** Independent scoring, historical validation, transparency **Analysis Paralysis:** - **Problem:** Endless refinement without decision making - **Solution:** Set decision deadlines, "good enough" thresholds ### 3. Organizational Change Management **Building Buy-In:** - Involve stakeholders in model selection process - Provide training on chosen methodology - Start with pilot group before full rollout - Demonstrate early wins from improved prioritization **Managing Resistance:** - Address concerns about "pet projects" being deprioritized - Show how model supports rather than replaces judgment - Provide transparency into scoring rationale - Allow for appeals process with clear criteria **Continuous Improvement:** - Regular retrospectives on prioritization effectiveness - Gather feedback from project teams and stakeholders - Update models based on changing business context - Share success stories and lessons learned --- ## Tools and Templates ### 1. Excel-Based Prioritization Templates **WSJF Calculator:** - Automated score calculation - Sensitivity analysis for weight changes - Portfolio-level aggregation - Visual ranking dashboard **RICE Framework Spreadsheet:** - Reach estimation guidelines - Impact scoring rubric - Confidence level definitions - Effort estimation templates ### 2. Decision Support Dashboards **Portfolio Overview:** - Current project distribution across models - Resource allocation vs. strategic priorities - Risk-return visualization - Priority change tracking **Stakeholder Views:** - Executive summary of top priorities - Department-specific project impacts - Budget allocation by strategic theme - Timeline and milestone visualization ### 3. Governance Integration **Portfolio Review Templates:** - Monthly priority health check - Quarterly strategic alignment review - Annual prioritization methodology assessment - Exception handling procedures --- ## Advanced Topics ### 1. Machine Learning Enhanced Prioritization **Predictive Scoring:** - Use historical project data to improve scoring accuracy - Identify patterns in successful vs. failed initiatives - Automate routine scoring updates - Flag projects with unusual risk profiles **Natural Language Processing:** - Analyze project descriptions for implicit risk factors - Extract customer sentiment from feedback data - Monitor market signals for priority implications - Automate competitive intelligence gathering ### 2. Real-Time Priority Adjustment **Market Signal Integration:** - Customer satisfaction scores - Competitive intelligence - Regulatory changes - Technology disruption indicators **Internal Signal Monitoring:** - Resource availability changes - Budget reforecasts - Strategic initiative launches - Organizational restructuring ### 3. Portfolio Scenario Planning **What-If Analysis:** - Impact of budget cuts on portfolio balance - Effect of resource constraints on delivery timelines - Strategic pivot implications for current priorities - Market disruption response strategies --- *This framework should be customized based on organizational maturity, industry context, and strategic objectives. Regular updates should incorporate lessons learned and evolving best practices.* FILE:references/risk-management-framework.md # Risk Management Framework for Senior Project Managers ## Executive Summary This framework provides senior project managers with quantitative risk analysis methodologies, decision frameworks, and portfolio-level risk management strategies. It goes beyond basic risk identification to provide sophisticated tools for risk quantification, Monte Carlo simulation, expected monetary value (EMV) analysis, and enterprise risk appetite frameworks. --- ## Risk Classification & Quantification ### Risk Categories with Quantitative Weightings #### 1. Technical Risk (Weight: 1.2x) **Definition:** Technology implementation, integration, and performance risks **Quantification Approach:** - **Technology Maturity Score (TMS):** 1-5 scale based on technology adoption curve - **Integration Complexity Index (ICI):** Number of integration points × complexity factor - **Performance Risk Factor (PRF):** Historical performance variance in similar projects **Formula:** `Technical Risk Score = (TMS × 0.3 + ICI × 0.4 + PRF × 0.3) × 1.2` **Typical Sub-Risks:** - Architecture scalability limitations (Impact: Schedule +15-30%, Cost +10-25%) - Third-party integration failures (Impact: Schedule +20-40%, Cost +15-30%) - Performance bottlenecks (Impact: Quality -20-40%, Cost +5-15%) - Technology obsolescence (Impact: Long-term maintenance +50-100%) #### 2. Resource Risk (Weight: 1.1x) **Definition:** Human capital availability, skills, and retention risks **Quantification Approach:** - **Skill Availability Index (SAI):** Market availability of required skills (1-5) - **Team Stability Factor (TSF):** Historical turnover rate in similar roles - **Capacity Utilization Ratio (CUR):** Team utilization vs. sustainable capacity **Formula:** `Resource Risk Score = (SAI × 0.4 + TSF × 0.3 + CUR × 0.3) × 1.1` **Financial Impact Models:** - Key person departure: 3-6 months replacement + 2-4 weeks knowledge transfer - Skill gap: 15-30% productivity reduction + training/hiring costs - Over-utilization: 20-40% quality degradation + burnout-related delays #### 3. Schedule Risk (Weight: 1.0x) **Definition:** Timeline compression, dependencies, and critical path risks **Quantification Method: Monte Carlo Simulation** ``` Three-Point Estimation: - Optimistic (O): Best case scenario (10% probability) - Most Likely (M): Realistic estimate (50% probability) - Pessimistic (P): Worst case scenario (90% probability) Expected Duration = (O + 4M + P) / 6 Standard Deviation = (P - O) / 6 Monte Carlo Variables: - Task duration uncertainty - Resource availability variations - Dependency delay impacts - External factor disruptions ``` #### 4. Financial Risk (Weight: 1.4x) **Definition:** Budget overruns, funding availability, and cost variability risks **Expected Monetary Value (EMV) Analysis:** ``` EMV = Σ(Probability × Impact) for all financial risk scenarios Cost Escalation Model: - Labor cost inflation: Historical rate ± standard deviation - Technology cost changes: Market volatility analysis - Scope creep financial impact: Historical data from similar projects - Currency/economic factors: Economic indicators correlation Risk-Adjusted Budget = Base Budget × (1 + Risk Premium) Risk Premium = Portfolio Risk Score × Risk Tolerance Factor ``` --- ## Quantitative Risk Analysis Methodologies ### 1. Expected Monetary Value (EMV) Analysis **Purpose:** Quantify financial impact of risks to inform investment decisions **Process:** 1. **Risk Event Identification:** Catalog all potential financial impact events 2. **Probability Assessment:** Use historical data, expert judgment, and statistical models 3. **Impact Quantification:** Model financial consequences across multiple scenarios 4. **EMV Calculation:** Probability × Financial Impact for each risk 5. **Portfolio EMV:** Sum of all individual risk EMVs **Example EMV Calculation:** ``` Risk: Third-party API failure requiring alternative implementation Probability Scenarios: - Minor disruption (60% chance): $50K additional cost - Major redesign (30% chance): $200K additional cost - Complete platform change (10% chance): $500K additional cost EMV = (0.6 × $50K) + (0.3 × $200K) + (0.1 × $500K) EMV = $30K + $60K + $50K = $140K Risk-adjusted budget should include $140K contingency for this risk. ``` ### 2. Monte Carlo Simulation for Schedule Risk **Purpose:** Model schedule uncertainty using probabilistic analysis **Implementation Process:** 1. **Task Duration Modeling:** Define probability distributions for each task 2. **Dependency Mapping:** Model task dependencies and their uncertainty 3. **Resource Constraint Integration:** Include resource availability variations 4. **External Factor Variables:** Weather, regulatory approvals, vendor delays 5. **Simulation Execution:** Run 10,000+ iterations to generate probability curves **Key Outputs:** - **P50 Schedule:** 50% confidence completion date - **P80 Schedule:** 80% confidence completion date (recommended for commitments) - **P95 Schedule:** 95% confidence completion date (worst-case planning) - **Critical Path Sensitivity:** Which tasks most impact overall schedule **Schedule Risk Interpretation:** ``` If P50 = 6 months, P80 = 7.5 months: - Schedule Buffer Required: 1.5 months (25% buffer) - Risk Level: Medium (broad distribution indicates uncertainty) - Mitigation Priority: Focus on tasks with highest variance contribution ``` ### 3. Risk Appetite & Tolerance Frameworks #### Enterprise Risk Appetite Levels **Conservative (Risk Score Target: 0-8)** - **Philosophy:** Minimize risk exposure, accept lower returns for certainty - **Suitable Projects:** Core business operations, regulatory compliance, customer-facing systems - **Contingency Reserves:** 20-30% of project budget - **Decision Criteria:** Require 90%+ confidence levels for major decisions **Moderate (Risk Score Target: 8-15)** - **Philosophy:** Balanced risk-return approach, selective risk taking - **Suitable Projects:** Process improvements, technology upgrades, market expansion - **Contingency Reserves:** 15-20% of project budget - **Decision Criteria:** 70-80% confidence levels acceptable **Aggressive (Risk Score Target: 15+)** - **Philosophy:** High risk tolerance for high strategic returns - **Suitable Projects:** Innovation initiatives, emerging technology adoption, new market entry - **Contingency Reserves:** 10-15% of project budget (accept higher failure rates) - **Decision Criteria:** 60-70% confidence levels acceptable #### Risk Tolerance Thresholds **Financial Tolerance Levels:** - **Level 1:** <$100K potential loss - Team/PM authority - **Level 2:** $100K-$500K potential loss - Business unit approval required - **Level 3:** $500K-$2M potential loss - Executive committee approval - **Level 4:** >$2M potential loss - Board approval required **Schedule Tolerance Levels:** - **Green:** <5% schedule impact - Monitor and mitigate - **Amber:** 5-15% schedule impact - Active mitigation required - **Red:** >15% schedule impact - Escalation and replanning required --- ## Advanced Risk Modeling Techniques ### 1. Correlation Analysis for Portfolio Risk **Purpose:** Understand how risks interact across projects and compound at portfolio level **Correlation Types:** - **Positive Correlation:** Risks that tend to occur together (e.g., economic downturn affecting multiple projects) - **Negative Correlation:** Risks that are mutually exclusive (e.g., resource conflicts between projects) - **No Correlation:** Independent risks **Portfolio Risk Calculation:** ``` Portfolio Variance = Σ(Individual Project Variance) + 2Σ(Correlation × StdDev1 × StdDev2) Where correlation coefficients range from -1.0 to +1.0: - +1.0: Perfect positive correlation (risks always occur together) - 0.0: No correlation (risks are independent) - -1.0: Perfect negative correlation (risks never occur together) ``` ### 2. Value at Risk (VaR) for Project Portfolios **Definition:** Maximum expected loss over a specific time period at a given confidence level **Calculation Example:** ``` For a portfolio with expected value of $10M and monthly VaR of $500K at 95% confidence: "There is a 95% chance that portfolio losses will not exceed $500K in any given month" VaR Calculation Methods: 1. Historical Simulation: Use past project performance data 2. Parametric Method: Assume normal distribution of returns 3. Monte Carlo Simulation: Model complex risk interactions ``` ### 3. Real Options Analysis for Project Flexibility **Purpose:** Value the flexibility to modify project approach based on new information **Common Real Options in Projects:** - **Expansion Option:** Scale up successful projects - **Abandonment Option:** Exit failing projects early - **Timing Option:** Delay project start for better conditions - **Switching Option:** Change technology/approach mid-project **Black-Scholes Adaptation for Projects:** ``` Project Option Value = S₀ × N(d₁) - K × e^(-r×T) × N(d₂) Where: S₀ = Current project value estimate K = Required investment (strike price) r = Risk-free rate T = Time to decision point N(d) = Cumulative standard normal distribution ``` --- ## Risk Response Strategies with Decision Trees ### Strategy Selection Framework #### 1. Avoid (Eliminate Risk) **Decision Criteria:** - High impact + High probability risks - Cost of avoidance < Expected risk cost - Alternative approaches available **Examples:** - Choose proven technology over cutting-edge solutions - Eliminate high-risk features from scope - Change project approach entirely #### 2. Mitigate (Reduce Probability or Impact) **Decision Tree for Mitigation Investment:** ``` If (Risk EMV > Mitigation Cost × 1.5): Implement mitigation Else if (Risk Impact > Risk Tolerance Threshold): Consider partial mitigation Else: Accept risk ``` **Mitigation Effectiveness Factors:** - Cost efficiency: Mitigation cost ÷ Risk EMV reduction - Implementation feasibility: Resource availability and timeline - Residual risk: Remaining risk after mitigation #### 3. Transfer (Share Risk with Others) **Transfer Mechanisms:** - Insurance: For predictable, quantifiable risks - Contracts: Fixed-price contracts transfer cost risk to vendors - Partnerships: Share both risks and rewards - Outsourcing: Transfer operational risks to specialists **Transfer Decision Matrix:** | Risk Type | Transfer Mechanism | Cost Efficiency | Risk Retention | |-----------|-------------------|-----------------|----------------| | Technical | Fixed-price contract | High | Low | | Schedule | Penalty clauses | Medium | Medium | | Market | Revenue sharing | Low | High | | Operational | Insurance/SLA | High | Low | #### 4. Accept (Acknowledge and Monitor) **Acceptance Criteria:** - Low impact × Low probability risks - Mitigation cost > Risk EMV - Risk within established tolerance thresholds **Active Acceptance:** Establish contingency reserves and response plans **Passive Acceptance:** Monitor but take no proactive action --- ## Risk Monitoring & Key Performance Indicators ### Risk Health Metrics #### 1. Portfolio Risk Exposure Trends ``` Risk Velocity = (New Risks Added - Risks Resolved) / Time Period Risk Burn Rate = Total Risk EMV Reduction / Time Period Risk Coverage Ratio = Mitigation Budget / Total Risk EMV ``` #### 2. Risk Response Effectiveness ``` Mitigation Success Rate = Risks Successfully Mitigated / Total Mitigation Attempts Average Resolution Time = Σ(Risk Resolution Days) / Number of Resolved Risks Cost of Risk Management = Total Risk Management Spend / Project Budget ``` #### 3. Leading vs. Lagging Indicators **Leading Indicators (Predictive):** - Resource utilization trends - Stakeholder satisfaction scores - Technical debt accumulation - Team velocity variance - Budget burn rate vs. planned **Lagging Indicators (Confirmatory):** - Actual schedule delays - Budget overruns - Quality defect rates - Stakeholder complaints - Team turnover events ### Risk Dashboard Design **Executive Level (Strategic View):** - Portfolio risk heat map - Top 10 risks by EMV - Risk appetite vs. actual exposure - Risk-adjusted project ROI **Program Level (Tactical View):** - Risk trend analysis - Mitigation plan status - Resource allocation for risk management - Cross-project risk correlations **Project Level (Operational View):** - Individual risk register - Risk response action items - Risk probability/impact changes - Mitigation cost tracking --- ## Integration with Portfolio Management ### Strategic Risk Alignment **Risk-Adjusted Portfolio Optimization:** 1. **Risk-Return Analysis:** Plot projects on risk vs. return matrix 2. **Portfolio Diversification:** Balance high-risk/high-reward with stable projects 3. **Resource Allocation:** Allocate risk management resources based on EMV 4. **Strategic Fit:** Ensure risk appetite aligns with strategic objectives **Capital Allocation Models:** ``` Risk-Adjusted NPV = Standard NPV × Risk Adjustment Factor Risk Adjustment Factor = 1 - (Project Risk Score × Risk Penalty Rate) Where Risk Penalty Rate reflects organization's risk aversion: - Conservative: 0.8% per risk score point - Moderate: 0.5% per risk score point - Aggressive: 0.2% per risk score point ``` ### Governance Integration **Risk Committee Structure:** - **Executive Risk Committee:** Monthly, strategic risks >$1M impact - **Portfolio Risk Board:** Bi-weekly, cross-project risks - **Project Risk Teams:** Weekly, operational risk management **Escalation Triggers:** - Risk EMV exceeds defined thresholds - Risk probability or impact significantly changes - Mitigation plans fail or become ineffective - New risk categories emerge **Decision Authority Matrix:** | Risk EMV Level | Authority Level | Response Time | Required Documentation | |----------------|-----------------|---------------|------------------------| | <$50K | Project Manager | 24 hours | Risk register update | | $50K-$250K | Program Manager | 48 hours | Risk assessment report | | $250K-$1M | Business Owner | 72 hours | Executive summary + options | | >$1M | Executive Committee | 1 week | Full risk analysis + recommendation | --- ## Advanced Topics ### Behavioral Risk Factors **Cognitive Biases in Risk Assessment:** - **Optimism Bias:** Tendency to underestimate risk probability - **Anchoring Bias:** Over-reliance on first information received - **Availability Heuristic:** Overweighting easily recalled risks - **Confirmation Bias:** Seeking information that confirms existing beliefs **Bias Mitigation Techniques:** - Independent risk assessments from multiple sources - Devil's advocate roles in risk sessions - Historical data analysis vs. expert judgment - Pre-mortem analysis: "How could this project fail?" ### Emerging Risk Categories **Digital Transformation Risks:** - Data privacy and cybersecurity (GDPR, CCPA compliance) - Legacy system integration complexity - Change management and user adoption - Cloud migration and vendor lock-in **Regulatory and Compliance Risks:** - Changing regulatory landscape - Cross-border data transfer restrictions - Industry-specific compliance requirements - Audit and documentation requirements **Sustainability and ESG Risks:** - Environmental impact assessments - Social responsibility requirements - Governance and ethical considerations - Long-term sustainability of solutions --- ## Implementation Guidelines ### Risk Framework Maturity Model **Level 1 - Basic (Ad Hoc):** - Qualitative risk identification - Simple probability/impact matrices - Reactive risk response - Project-level focus only **Level 2 - Managed (Repeatable):** - Standardized risk processes - Quantitative risk analysis - Proactive mitigation planning - Portfolio-level risk aggregation **Level 3 - Defined (Systematic):** - Enterprise risk integration - Monte Carlo simulation - Risk-adjusted decision making - Cross-functional risk management **Level 4 - Advanced (Quantitative):** - Real-time risk monitoring - Predictive risk analytics - Automated risk reporting - Strategic risk optimization **Level 5 - Optimizing (Continuous Improvement):** - AI-enhanced risk prediction - Dynamic risk response - Industry benchmark integration - Continuous framework evolution ### Getting Started: 90-Day Implementation Plan **Days 1-30: Foundation** - Assess current risk management maturity - Define risk appetite and tolerance levels - Establish risk governance structure - Train core team on quantitative methods **Days 31-60: Tools & Processes** - Implement EMV and Monte Carlo tools - Create risk dashboard templates - Establish risk register standards - Begin historical data collection **Days 61-90: Integration & Optimization** - Integrate with portfolio management - Establish reporting rhythms - Conduct first portfolio risk review - Plan continuous improvement initiatives --- *This framework should be adapted to organizational context, industry requirements, and project complexity. Regular updates should incorporate lessons learned and emerging best practices.* FILE:scripts/project_health_dashboard.py #!/usr/bin/env python3 """ Project Health Dashboard Aggregates project metrics across timeline, budget, scope, and quality dimensions. Calculates composite health scores, generates RAG (Red/Amber/Green) status reports, and identifies projects needing intervention for portfolio management. Usage: python project_health_dashboard.py portfolio_data.json python project_health_dashboard.py portfolio_data.json --format json """ import argparse import json import statistics import sys from datetime import datetime, timedelta from typing import Any, Dict, List, Optional, Tuple, Union # --------------------------------------------------------------------------- # Health Assessment Configuration # --------------------------------------------------------------------------- HEALTH_DIMENSIONS = { "timeline": { "weight": 0.25, "thresholds": { "green": {"min": 0.0, "max": 0.05}, # ≤5% delay "amber": {"min": 0.05, "max": 0.15}, # 5-15% delay "red": {"min": 0.15, "max": 1.0} # >15% delay } }, "budget": { "weight": 0.25, "thresholds": { "green": {"min": 0.0, "max": 0.05}, # ≤5% over budget "amber": {"min": 0.05, "max": 0.15}, # 5-15% over budget "red": {"min": 0.15, "max": 1.0} # >15% over budget } }, "scope": { "weight": 0.20, "thresholds": { "green": {"min": 0.90, "max": 1.0}, # 90-100% scope delivered "amber": {"min": 0.75, "max": 0.90}, # 75-90% scope delivered "red": {"min": 0.0, "max": 0.75} # <75% scope delivered } }, "quality": { "weight": 0.20, "thresholds": { "green": {"min": 0.95, "max": 1.0}, # ≤5% defect rate "amber": {"min": 0.85, "max": 0.95}, # 5-15% defect rate "red": {"min": 0.0, "max": 0.85} # >15% defect rate } }, "risk": { "weight": 0.10, "thresholds": { "green": {"min": 0.0, "max": 15}, # Low risk score "amber": {"min": 15, "max": 25}, # Medium risk score "red": {"min": 25, "max": 100} # High risk score } } } PROJECT_STATUS_MAPPING = { "planning": ["planning", "initiation", "chartered"], "active": ["active", "in_progress", "execution", "development"], "monitoring": ["monitoring", "testing", "review"], "completed": ["completed", "delivered", "closed"], "cancelled": ["cancelled", "terminated", "suspended"], "on_hold": ["on_hold", "paused", "blocked"] } PRIORITY_WEIGHTS = { "critical": 1.5, "high": 1.2, "medium": 1.0, "low": 0.8 } INTERVENTION_THRESHOLDS = { "immediate": 30, # Health score ≤30 "urgent": 50, # Health score ≤50 "monitor": 70 # Health score ≤70 } # --------------------------------------------------------------------------- # Data Models # --------------------------------------------------------------------------- class ProjectMetrics: """Represents project health metrics and calculations.""" def __init__(self, data: Dict[str, Any]): self.project_id: str = data.get("project_id", "") self.project_name: str = data.get("project_name", "") self.priority: str = data.get("priority", "medium").lower() self.status: str = data.get("status", "planning").lower() self.phase: str = data.get("phase", "planning") # Timeline metrics self.planned_start: str = data.get("planned_start", "") self.actual_start: Optional[str] = data.get("actual_start") self.planned_end: str = data.get("planned_end", "") self.forecasted_end: str = data.get("forecasted_end", "") self.completion_percentage: float = max(0, min(100, data.get("completion_percentage", 0))) / 100 # Budget metrics self.planned_budget: float = data.get("planned_budget", 0) self.spent_to_date: float = data.get("spent_to_date", 0) self.forecasted_total_cost: float = data.get("forecasted_total_cost", 0) # Scope metrics self.planned_features: int = data.get("planned_features", 0) self.completed_features: int = data.get("completed_features", 0) self.descoped_features: int = data.get("descoped_features", 0) self.added_features: int = data.get("added_features", 0) # Quality metrics self.total_defects: int = data.get("total_defects", 0) self.resolved_defects: int = data.get("resolved_defects", 0) self.critical_defects: int = data.get("critical_defects", 0) self.test_coverage: float = max(0, min(1, data.get("test_coverage", 0))) # Risk metrics self.risk_score: float = data.get("risk_score", 0) self.open_risks: int = data.get("open_risks", 0) self.critical_risks: int = data.get("critical_risks", 0) # Team metrics self.team_size: int = data.get("team_size", 0) self.team_utilization: float = data.get("team_utilization", 0) self.team_satisfaction: Optional[float] = data.get("team_satisfaction") # Stakeholder metrics self.stakeholder_satisfaction: Optional[float] = data.get("stakeholder_satisfaction") self.last_status_update: str = data.get("last_status_update", "") # Calculate derived metrics self._calculate_health_metrics() self._normalize_status() def _calculate_health_metrics(self): """Calculate normalized health metrics for each dimension.""" # Timeline health (0 = on time, 1 = severely delayed) self.timeline_health = self._calculate_timeline_variance() # Budget health (0 = on budget, 1 = severely over budget) self.budget_health = self._calculate_budget_variance() # Scope health (0 = no scope delivered, 1 = full scope delivered) self.scope_health = self._calculate_scope_completion() # Quality health (0 = poor quality, 1 = excellent quality) self.quality_health = self._calculate_quality_score() # Risk health (normalized risk score) self.risk_health = min(self.risk_score, 100) # Cap at 100 def _calculate_timeline_variance(self) -> float: """Calculate timeline variance as percentage of planned duration.""" if not self.planned_start or not self.planned_end: return 0.0 try: planned_start = datetime.strptime(self.planned_start, "%Y-%m-%d") planned_end = datetime.strptime(self.planned_end, "%Y-%m-%d") planned_duration = (planned_end - planned_start).days if planned_duration <= 0: return 0.0 # Use forecasted end if available, otherwise current date for active projects if self.forecasted_end: forecast_date = datetime.strptime(self.forecasted_end, "%Y-%m-%d") elif self.status in ["completed", "cancelled"]: return 0.0 # Project is done else: forecast_date = datetime.now() actual_duration = (forecast_date - planned_start).days variance = max(0, actual_duration - planned_duration) / planned_duration return min(variance, 1.0) # Cap at 100% delay except (ValueError, ZeroDivisionError): return 0.0 def _calculate_budget_variance(self) -> float: """Calculate budget variance as percentage over original budget.""" if self.planned_budget <= 0: return 0.0 # Use forecasted total cost if available, otherwise spent to date actual_cost = self.forecasted_total_cost or self.spent_to_date variance = max(0, actual_cost - self.planned_budget) / self.planned_budget return min(variance, 1.0) # Cap at 100% over budget def _calculate_scope_completion(self) -> float: """Calculate scope completion percentage.""" if self.planned_features <= 0: return 1.0 # No planned features, consider complete # Account for scope changes effective_planned = self.planned_features + self.added_features - self.descoped_features if effective_planned <= 0: return 1.0 return self.completed_features / effective_planned def _calculate_quality_score(self) -> float: """Calculate quality score based on defects and test coverage.""" if self.total_defects == 0: defect_score = 1.0 else: resolution_rate = self.resolved_defects / self.total_defects critical_penalty = self.critical_defects / max(self.total_defects, 1) defect_score = resolution_rate * (1 - critical_penalty * 0.5) # Combine defect score with test coverage quality_score = (defect_score * 0.7) + (self.test_coverage * 0.3) return max(0, min(1, quality_score)) def _normalize_status(self): """Normalize project status to standard categories.""" status_lower = self.status.lower() for category, statuses in PROJECT_STATUS_MAPPING.items(): if status_lower in statuses: self.normalized_status = category return self.normalized_status = "active" # Default @property def is_active(self) -> bool: return self.normalized_status in ["planning", "active", "monitoring"] @property def requires_intervention(self) -> bool: health_score = self.calculate_composite_health_score() return health_score <= INTERVENTION_THRESHOLDS["urgent"] and self.is_active class PortfolioHealthResult: """Complete portfolio health analysis results.""" def __init__(self): self.summary: Dict[str, Any] = {} self.project_scores: List[Dict[str, Any]] = [] self.dimension_analysis: Dict[str, Any] = {} self.rag_status: Dict[str, Any] = {} self.intervention_list: List[Dict[str, Any]] = [] self.portfolio_trends: Dict[str, Any] = {} self.recommendations: List[str] = [] # --------------------------------------------------------------------------- # Health Calculation Functions # --------------------------------------------------------------------------- def calculate_dimension_score(value: float, dimension: str, is_reverse: bool = False) -> int: """Calculate dimension score (0-100) based on thresholds.""" config = HEALTH_DIMENSIONS[dimension] thresholds = config["thresholds"] if not is_reverse: # Lower values are better (timeline, budget, risk) if value <= thresholds["green"]["max"]: return 90 + int((1 - value / thresholds["green"]["max"]) * 10) elif value <= thresholds["amber"]["max"]: range_size = thresholds["amber"]["max"] - thresholds["amber"]["min"] position = (value - thresholds["amber"]["min"]) / range_size return 60 + int((1 - position) * 30) else: # Red zone - score decreases with higher values excess = min(value - thresholds["red"]["min"], 1.0) return max(10, 60 - int(excess * 50)) else: # Higher values are better (scope, quality) if value >= thresholds["green"]["min"]: range_size = thresholds["green"]["max"] - thresholds["green"]["min"] position = (value - thresholds["green"]["min"]) / range_size if range_size > 0 else 1 return 90 + int(position * 10) elif value >= thresholds["amber"]["min"]: range_size = thresholds["amber"]["max"] - thresholds["amber"]["min"] position = (value - thresholds["amber"]["min"]) / range_size return 60 + int(position * 30) else: # Red zone if thresholds["red"]["max"] > 0: position = value / thresholds["red"]["max"] return max(10, int(position * 60)) else: return 10 def calculate_project_health_score(project: ProjectMetrics) -> Dict[str, Any]: """Calculate comprehensive health score for a project.""" # Calculate individual dimension scores timeline_score = calculate_dimension_score(project.timeline_health, "timeline") budget_score = calculate_dimension_score(project.budget_health, "budget") scope_score = calculate_dimension_score(project.scope_health, "scope", is_reverse=True) quality_score = calculate_dimension_score(project.quality_health, "quality", is_reverse=True) risk_score = calculate_dimension_score(project.risk_health, "risk") # Calculate weighted composite score dimensions = { "timeline": {"score": timeline_score, "weight": HEALTH_DIMENSIONS["timeline"]["weight"]}, "budget": {"score": budget_score, "weight": HEALTH_DIMENSIONS["budget"]["weight"]}, "scope": {"score": scope_score, "weight": HEALTH_DIMENSIONS["scope"]["weight"]}, "quality": {"score": quality_score, "weight": HEALTH_DIMENSIONS["quality"]["weight"]}, "risk": {"score": risk_score, "weight": HEALTH_DIMENSIONS["risk"]["weight"]} } composite_score = sum( dim_data["score"] * dim_data["weight"] for dim_data in dimensions.values() ) # Apply priority weighting priority_weight = PRIORITY_WEIGHTS.get(project.priority, 1.0) adjusted_score = composite_score * priority_weight # Determine RAG status if composite_score >= 80: rag_status = "green" elif composite_score >= 60: rag_status = "amber" else: rag_status = "red" # Determine intervention level if composite_score <= INTERVENTION_THRESHOLDS["immediate"]: intervention_level = "immediate" elif composite_score <= INTERVENTION_THRESHOLDS["urgent"]: intervention_level = "urgent" elif composite_score <= INTERVENTION_THRESHOLDS["monitor"]: intervention_level = "monitor" else: intervention_level = "none" return { "project_id": project.project_id, "project_name": project.project_name, "composite_score": composite_score, "adjusted_score": adjusted_score, "rag_status": rag_status, "intervention_level": intervention_level, "dimension_scores": dimensions, "priority": project.priority, "status": project.status, "completion_percentage": project.completion_percentage } def analyze_portfolio_dimensions(project_scores: List[Dict[str, Any]]) -> Dict[str, Any]: """Analyze portfolio performance across health dimensions.""" dimension_analysis = {} for dimension in HEALTH_DIMENSIONS.keys(): scores = [ project["dimension_scores"][dimension]["score"] for project in project_scores ] if scores: dimension_analysis[dimension] = { "average_score": statistics.mean(scores), "median_score": statistics.median(scores), "min_score": min(scores), "max_score": max(scores), "std_deviation": statistics.stdev(scores) if len(scores) > 1 else 0, "projects_below_60": len([s for s in scores if s < 60]), "projects_above_80": len([s for s in scores if s >= 80]) } # Identify weakest and strongest dimensions avg_scores = {dim: data["average_score"] for dim, data in dimension_analysis.items()} weakest_dimension = min(avg_scores.keys(), key=lambda k: avg_scores[k]) strongest_dimension = max(avg_scores.keys(), key=lambda k: avg_scores[k]) return { "dimension_statistics": dimension_analysis, "weakest_dimension": weakest_dimension, "strongest_dimension": strongest_dimension, "dimension_rankings": sorted(avg_scores.items(), key=lambda x: x[1], reverse=True) } def generate_rag_status_summary(project_scores: List[Dict[str, Any]]) -> Dict[str, Any]: """Generate RAG status summary for portfolio.""" rag_counts = {"green": 0, "amber": 0, "red": 0} # Count by RAG status for project in project_scores: rag_status = project["rag_status"] rag_counts[rag_status] += 1 total_projects = len(project_scores) # Calculate percentages rag_percentages = { status: (count / max(total_projects, 1)) * 100 for status, count in rag_counts.items() } # Categorize projects by status green_projects = [p for p in project_scores if p["rag_status"] == "green"] amber_projects = [p for p in project_scores if p["rag_status"] == "amber"] red_projects = [p for p in project_scores if p["rag_status"] == "red"] # Calculate portfolio health grade if rag_percentages["red"] > 30: portfolio_grade = "critical" elif rag_percentages["red"] > 15 or rag_percentages["amber"] > 50: portfolio_grade = "concerning" elif rag_percentages["green"] > 60: portfolio_grade = "healthy" else: portfolio_grade = "moderate" return { "rag_counts": rag_counts, "rag_percentages": rag_percentages, "portfolio_grade": portfolio_grade, "green_projects": [{"id": p["project_id"], "name": p["project_name"], "score": p["composite_score"]} for p in green_projects], "amber_projects": [{"id": p["project_id"], "name": p["project_name"], "score": p["composite_score"]} for p in amber_projects], "red_projects": [{"id": p["project_id"], "name": p["project_name"], "score": p["composite_score"]} for p in red_projects] } def identify_intervention_priorities(project_scores: List[Dict[str, Any]]) -> List[Dict[str, Any]]: """Identify projects requiring intervention, prioritized by urgency and impact.""" intervention_projects = [ p for p in project_scores if p["intervention_level"] in ["immediate", "urgent", "monitor"] ] # Sort by intervention level and then by adjusted score (priority-weighted) intervention_priority = {"immediate": 3, "urgent": 2, "monitor": 1} intervention_projects.sort( key=lambda p: ( intervention_priority[p["intervention_level"]], -p["adjusted_score"] # Lower scores need more urgent attention ), reverse=True ) # Add recommended actions based on weakest dimensions for project in intervention_projects: project["recommended_actions"] = _generate_project_recommendations(project) project["risk_factors"] = _identify_risk_factors(project) return intervention_projects def _generate_project_recommendations(project: Dict[str, Any]) -> List[str]: """Generate specific recommendations based on project's weak dimensions.""" recommendations = [] dimension_scores = project["dimension_scores"] # Timeline recommendations if dimension_scores["timeline"]["score"] < 60: recommendations.append("Conduct timeline recovery analysis and implement fast-tracking or crashing strategies") # Budget recommendations if dimension_scores["budget"]["score"] < 60: recommendations.append("Implement cost control measures and review budget forecasts") # Scope recommendations if dimension_scores["scope"]["score"] < 60: recommendations.append("Review scope management and consider feature prioritization or descoping") # Quality recommendations if dimension_scores["quality"]["score"] < 60: recommendations.append("Increase testing coverage and implement quality improvement processes") # Risk recommendations if dimension_scores["risk"]["score"] < 60: recommendations.append("Escalate critical risks and implement additional risk mitigation measures") # Overall health recommendations if project["composite_score"] < 40: recommendations.append("Consider project restructuring or emergency stakeholder review") return recommendations def _identify_risk_factors(project: Dict[str, Any]) -> List[str]: """Identify specific risk factors for a project.""" risk_factors = [] if project["composite_score"] < 30: risk_factors.append("Critical project failure risk") if project["intervention_level"] == "immediate": risk_factors.append("Requires immediate management attention") dimension_scores = project["dimension_scores"] poor_dimensions = [ dim for dim, data in dimension_scores.items() if data["score"] < 50 ] if len(poor_dimensions) > 2: risk_factors.append(f"Multiple failing dimensions: {', '.join(poor_dimensions)}") return risk_factors def generate_portfolio_recommendations(analysis_results: Dict[str, Any]) -> List[str]: """Generate portfolio-level recommendations.""" recommendations = [] # RAG status recommendations rag_status = analysis_results.get("rag_status", {}) red_percentage = rag_status.get("rag_percentages", {}).get("red", 0) amber_percentage = rag_status.get("rag_percentages", {}).get("amber", 0) if red_percentage > 30: recommendations.append("URGENT: 30%+ projects are in red status. Consider portfolio restructuring or resource reallocation.") elif red_percentage > 15: recommendations.append("HIGH: Significant number of projects in red status require immediate attention.") if amber_percentage > 50: recommendations.append("MEDIUM: Over half of portfolio projects need monitoring and support.") # Dimension-based recommendations dimension_analysis = analysis_results.get("dimension_analysis", {}) weakest_dimension = dimension_analysis.get("weakest_dimension", "") if weakest_dimension: recommendations.append(f"Focus improvement efforts on {weakest_dimension} - weakest portfolio dimension.") # Intervention recommendations intervention_list = analysis_results.get("intervention_list", []) immediate_count = len([p for p in intervention_list if p["intervention_level"] == "immediate"]) urgent_count = len([p for p in intervention_list if p["intervention_level"] == "urgent"]) if immediate_count > 0: recommendations.append(f"CRITICAL: {immediate_count} projects require immediate intervention within 48 hours.") if urgent_count > 3: recommendations.append(f"Capacity alert: {urgent_count} projects need urgent attention - consider resource reallocation.") # Portfolio health recommendations portfolio_grade = rag_status.get("portfolio_grade", "") if portfolio_grade == "critical": recommendations.append("Portfolio health is critical. Recommend executive review and strategic realignment.") elif portfolio_grade == "concerning": recommendations.append("Portfolio health needs improvement. Implement enhanced monitoring and support.") return recommendations # --------------------------------------------------------------------------- # Main Analysis Function # --------------------------------------------------------------------------- def analyze_portfolio_health(data: Dict[str, Any]) -> PortfolioHealthResult: """Perform comprehensive portfolio health analysis.""" result = PortfolioHealthResult() try: # Parse project data project_records = data.get("projects", []) projects = [ProjectMetrics(record) for record in project_records] if not projects: raise ValueError("No project data found") # Calculate health scores for each project project_scores = [calculate_project_health_score(project) for project in projects] result.project_scores = project_scores # Filter active projects for portfolio analysis active_scores = [score for i, score in enumerate(project_scores) if projects[i].is_active] # Portfolio summary if active_scores: composite_scores = [score["composite_score"] for score in active_scores] result.summary = { "total_projects": len(projects), "active_projects": len(active_scores), "portfolio_average_score": statistics.mean(composite_scores), "portfolio_median_score": statistics.median(composite_scores), "projects_needing_attention": len([s for s in active_scores if s["composite_score"] < 70]), "critical_projects": len([s for s in active_scores if s["composite_score"] < 40]) } else: result.summary = { "total_projects": len(projects), "active_projects": 0, "portfolio_average_score": 0, "message": "No active projects found" } if active_scores: # Dimension analysis result.dimension_analysis = analyze_portfolio_dimensions(active_scores) # RAG status analysis result.rag_status = generate_rag_status_summary(active_scores) # Intervention priorities result.intervention_list = identify_intervention_priorities(active_scores) # Generate recommendations analysis_data = { "rag_status": result.rag_status, "dimension_analysis": result.dimension_analysis, "intervention_list": result.intervention_list } result.recommendations = generate_portfolio_recommendations(analysis_data) except Exception as e: result.summary = {"error": str(e)} return result # --------------------------------------------------------------------------- # Output Formatting # --------------------------------------------------------------------------- def format_text_output(result: PortfolioHealthResult) -> str: """Format analysis results as readable text report.""" lines = [] lines.append("="*60) lines.append("PROJECT HEALTH DASHBOARD") lines.append("="*60) lines.append("") if "error" in result.summary: lines.append(f"ERROR: {result.summary['error']}") return "\n".join(lines) # Executive Summary summary = result.summary lines.append("PORTFOLIO OVERVIEW") lines.append("-"*30) lines.append(f"Total Projects: {summary['total_projects']} ({summary.get('active_projects', 0)} active)") if "portfolio_average_score" in summary: lines.append(f"Portfolio Health Score: {summary['portfolio_average_score']:.1f}/100") lines.append(f"Projects Needing Attention: {summary.get('projects_needing_attention', 0)}") lines.append(f"Critical Projects: {summary.get('critical_projects', 0)}") if "message" in summary: lines.append(f"Status: {summary['message']}") lines.append("") # RAG Status Summary rag_status = result.rag_status if rag_status: lines.append("RAG STATUS SUMMARY") lines.append("-"*30) rag_counts = rag_status.get("rag_counts", {}) rag_percentages = rag_status.get("rag_percentages", {}) lines.append(f"🟢 Green: {rag_counts.get('green', 0)} ({rag_percentages.get('green', 0):.1f}%)") lines.append(f"🟡 Amber: {rag_counts.get('amber', 0)} ({rag_percentages.get('amber', 0):.1f}%)") lines.append(f"🔴 Red: {rag_counts.get('red', 0)} ({rag_percentages.get('red', 0):.1f}%)") lines.append(f"Portfolio Grade: {rag_status.get('portfolio_grade', 'N/A').title()}") lines.append("") # Dimension Analysis dimension_analysis = result.dimension_analysis if dimension_analysis: lines.append("HEALTH DIMENSION ANALYSIS") lines.append("-"*30) dimension_stats = dimension_analysis.get("dimension_statistics", {}) for dimension, stats in dimension_stats.items(): lines.append(f"{dimension.title()}: {stats['average_score']:.1f} avg " f"({stats['projects_below_60']} below 60, {stats['projects_above_80']} above 80)") lines.append(f"Strongest: {dimension_analysis.get('strongest_dimension', '').title()}") lines.append(f"Weakest: {dimension_analysis.get('weakest_dimension', '').title()}") lines.append("") # Critical Projects Needing Intervention intervention_list = result.intervention_list if intervention_list: lines.append("PROJECTS REQUIRING INTERVENTION") lines.append("-"*30) immediate_projects = [p for p in intervention_list if p["intervention_level"] == "immediate"] urgent_projects = [p for p in intervention_list if p["intervention_level"] == "urgent"] if immediate_projects: lines.append("🚨 IMMEDIATE ACTION REQUIRED:") for project in immediate_projects[:5]: lines.append(f" • {project['project_name']} (Score: {project['composite_score']:.0f})") if project.get("recommended_actions"): lines.append(f" → {project['recommended_actions'][0]}") lines.append("") if urgent_projects: lines.append("⚠️ URGENT ATTENTION NEEDED:") for project in urgent_projects[:5]: lines.append(f" • {project['project_name']} (Score: {project['composite_score']:.0f})") lines.append("") # Top Performing Projects if result.project_scores: top_projects = sorted(result.project_scores, key=lambda p: p["composite_score"], reverse=True)[:5] lines.append("TOP PERFORMING PROJECTS") lines.append("-"*30) for project in top_projects: status_emoji = {"green": "🟢", "amber": "🟡", "red": "🔴"}.get(project["rag_status"], "⚫") lines.append(f"{status_emoji} {project['project_name']}: {project['composite_score']:.0f}/100") lines.append("") # Recommendations if result.recommendations: lines.append("PORTFOLIO RECOMMENDATIONS") lines.append("-"*30) for i, rec in enumerate(result.recommendations, 1): lines.append(f"{i}. {rec}") return "\n".join(lines) def format_json_output(result: PortfolioHealthResult) -> Dict[str, Any]: """Format analysis results as JSON.""" return { "summary": result.summary, "project_scores": result.project_scores, "dimension_analysis": result.dimension_analysis, "rag_status": result.rag_status, "intervention_list": result.intervention_list, "portfolio_trends": result.portfolio_trends, "recommendations": result.recommendations } # --------------------------------------------------------------------------- # ProjectMetrics Helper Method # --------------------------------------------------------------------------- def _calculate_composite_health_score(self) -> float: """Helper method to calculate composite health score.""" health_calc = calculate_project_health_score(self) return health_calc["composite_score"] # Add the method to the class ProjectMetrics.calculate_composite_health_score = lambda self: calculate_project_health_score(self)["composite_score"] # --------------------------------------------------------------------------- # CLI Interface # --------------------------------------------------------------------------- def main() -> int: """Main CLI entry point.""" parser = argparse.ArgumentParser( description="Analyze project portfolio health across multiple dimensions" ) parser.add_argument( "data_file", help="JSON file containing project portfolio data" ) parser.add_argument( "--format", choices=["text", "json"], default="text", help="Output format (default: text)" ) args = parser.parse_args() try: # Load and validate data with open(args.data_file, 'r') as f: data = json.load(f) # Perform analysis result = analyze_portfolio_health(data) # Output results if args.format == "json": output = format_json_output(result) print(json.dumps(output, indent=2)) else: output = format_text_output(result) print(output) return 0 except FileNotFoundError: print(f"Error: File '{args.data_file}' not found", file=sys.stderr) return 1 except json.JSONDecodeError as e: print(f"Error: Invalid JSON in '{args.data_file}': {e}", file=sys.stderr) return 1 except Exception as e: print(f"Error: {e}", file=sys.stderr) return 1 if __name__ == "__main__": sys.exit(main()) FILE:scripts/resource_capacity_planner.py #!/usr/bin/env python3 """ Resource Capacity Planner Models team capacity across projects, identifies over/under-allocation, simulates "what-if" scenarios for adding/removing resources, calculates utilization rates, and provides capacity optimization recommendations for project portfolios. Usage: python resource_capacity_planner.py capacity_data.json python resource_capacity_planner.py capacity_data.json --format json """ import argparse import json import statistics import sys from datetime import datetime, timedelta from typing import Any, Dict, List, Optional, Tuple, Union # --------------------------------------------------------------------------- # Capacity Planning Configuration # --------------------------------------------------------------------------- ROLE_TYPES = { "senior_engineer": { "hourly_rate": 150, "efficiency_factor": 1.2, "skill_multipliers": { "backend": 1.0, "frontend": 0.9, "mobile": 0.8, "devops": 1.1, "data": 0.9 } }, "mid_engineer": { "hourly_rate": 100, "efficiency_factor": 1.0, "skill_multipliers": { "backend": 1.0, "frontend": 1.0, "mobile": 0.9, "devops": 0.8, "data": 0.8 } }, "junior_engineer": { "hourly_rate": 70, "efficiency_factor": 0.7, "skill_multipliers": { "backend": 0.8, "frontend": 0.9, "mobile": 0.7, "devops": 0.6, "data": 0.7 } }, "product_manager": { "hourly_rate": 130, "efficiency_factor": 1.1, "skill_multipliers": { "planning": 1.0, "stakeholder_mgmt": 1.0, "analysis": 0.9 } }, "designer": { "hourly_rate": 90, "efficiency_factor": 1.0, "skill_multipliers": { "ui_design": 1.0, "ux_research": 1.0, "prototyping": 0.9 } }, "qa_engineer": { "hourly_rate": 80, "efficiency_factor": 0.9, "skill_multipliers": { "manual_testing": 1.0, "automation": 1.1, "performance": 0.9 } } } UTILIZATION_THRESHOLDS = { "under_utilized": 0.60, # Below 60% "optimal": 0.85, # 60-85% "over_utilized": 0.95, # 85-95% "critical": 1.0 # Above 95% } CAPACITY_FACTORS = { "meeting_overhead": 0.15, # 15% for meetings "learning_development": 0.05, # 5% for skill development "administrative": 0.10, # 10% for admin tasks "context_switching": 0.05, # 5% for project switching penalty "vacation_sick": 0.12 # 12% for time off } PROJECT_COMPLEXITY_FACTORS = { "simple": 1.0, "moderate": 1.2, "complex": 1.5, "very_complex": 2.0 } # --------------------------------------------------------------------------- # Data Models # --------------------------------------------------------------------------- class Resource: """Represents a team member with skills and capacity.""" def __init__(self, data: Dict[str, Any]): self.id: str = data.get("id", "") self.name: str = data.get("name", "") self.role: str = data.get("role", "").lower() self.skills: List[str] = data.get("skills", []) self.skill_levels: Dict[str, float] = data.get("skill_levels", {}) self.hourly_rate: float = data.get("hourly_rate", 0) self.max_hours_per_week: int = data.get("max_hours_per_week", 40) self.current_utilization: float = data.get("current_utilization", 0.0) self.availability_start: str = data.get("availability_start", "") self.availability_end: Optional[str] = data.get("availability_end") self.location: str = data.get("location", "") self.time_zone: str = data.get("time_zone", "") # Calculate derived metrics self._calculate_effective_capacity() self._determine_role_config() def _calculate_effective_capacity(self): """Calculate effective weekly capacity accounting for overhead.""" base_capacity = self.max_hours_per_week # Apply overhead factors overhead_total = sum(CAPACITY_FACTORS.values()) self.effective_hours_per_week = base_capacity * (1 - overhead_total) # Current available capacity self.available_hours = self.effective_hours_per_week * (1 - self.current_utilization) def _determine_role_config(self): """Get role configuration from predefined types.""" self.role_config = ROLE_TYPES.get(self.role, { "hourly_rate": self.hourly_rate or 100, "efficiency_factor": 1.0, "skill_multipliers": {} }) # Use provided rate if available, otherwise use role default if not self.hourly_rate: self.hourly_rate = self.role_config["hourly_rate"] def get_skill_effectiveness(self, skill: str) -> float: """Calculate effectiveness for a specific skill.""" base_level = self.skill_levels.get(skill, 0.5) # Default 50% if not specified multiplier = self.role_config.get("skill_multipliers", {}).get(skill, 1.0) efficiency = self.role_config.get("efficiency_factor", 1.0) return base_level * multiplier * efficiency def can_work_on_project(self, project_skills: List[str], min_effectiveness: float = 0.6) -> bool: """Check if resource can effectively work on project.""" for skill in project_skills: if skill in self.skills and self.get_skill_effectiveness(skill) >= min_effectiveness: return True return False class Project: """Represents a project with resource requirements.""" def __init__(self, data: Dict[str, Any]): self.id: str = data.get("id", "") self.name: str = data.get("name", "") self.priority: str = data.get("priority", "medium").lower() self.complexity: str = data.get("complexity", "moderate").lower() self.estimated_hours: int = data.get("estimated_hours", 0) self.start_date: str = data.get("start_date", "") self.target_end_date: str = data.get("target_end_date", "") self.required_skills: List[str] = data.get("required_skills", []) self.skill_requirements: Dict[str, int] = data.get("skill_requirements", {}) self.current_allocation: List[Dict[str, Any]] = data.get("current_allocation", []) self.status: str = data.get("status", "planned").lower() # Calculate derived metrics self._calculate_project_metrics() def _calculate_project_metrics(self): """Calculate project-specific metrics.""" # Apply complexity factor complexity_multiplier = PROJECT_COMPLEXITY_FACTORS.get(self.complexity, 1.0) self.adjusted_hours = self.estimated_hours * complexity_multiplier # Calculate current allocation self.currently_allocated_hours = sum( alloc.get("hours_per_week", 0) for alloc in self.current_allocation ) # Calculate timeline metrics if self.start_date and self.target_end_date: try: start = datetime.strptime(self.start_date, "%Y-%m-%d") end = datetime.strptime(self.target_end_date, "%Y-%m-%d") self.duration_weeks = (end - start).days / 7 # Required weekly capacity if self.duration_weeks > 0: self.required_hours_per_week = self.adjusted_hours / self.duration_weeks else: self.required_hours_per_week = self.adjusted_hours except ValueError: self.duration_weeks = 0 self.required_hours_per_week = 0 else: self.duration_weeks = 0 self.required_hours_per_week = 0 # Capacity gap self.capacity_gap = self.required_hours_per_week - self.currently_allocated_hours class CapacityAnalysisResult: """Complete capacity analysis results.""" def __init__(self): self.summary: Dict[str, Any] = {} self.resource_analysis: Dict[str, Any] = {} self.project_analysis: Dict[str, Any] = {} self.allocation_optimization: Dict[str, Any] = {} self.scenario_analysis: Dict[str, Any] = {} self.recommendations: List[str] = [] # --------------------------------------------------------------------------- # Capacity Analysis Functions # --------------------------------------------------------------------------- def analyze_resource_utilization(resources: List[Resource]) -> Dict[str, Any]: """Analyze current resource utilization and capacity.""" utilization_stats = { "total_resources": len(resources), "total_capacity": sum(r.effective_hours_per_week for r in resources), "total_allocated": sum(r.effective_hours_per_week * r.current_utilization for r in resources), "total_available": sum(r.available_hours for r in resources) } # Calculate overall utilization utilization_stats["overall_utilization"] = ( utilization_stats["total_allocated"] / max(utilization_stats["total_capacity"], 1) ) # Categorize resources by utilization utilization_categories = { "under_utilized": [], "optimal": [], "over_utilized": [], "critical": [] } for resource in resources: if resource.current_utilization <= UTILIZATION_THRESHOLDS["under_utilized"]: utilization_categories["under_utilized"].append(resource) elif resource.current_utilization <= UTILIZATION_THRESHOLDS["optimal"]: utilization_categories["optimal"].append(resource) elif resource.current_utilization <= UTILIZATION_THRESHOLDS["over_utilized"]: utilization_categories["over_utilized"].append(resource) else: utilization_categories["critical"].append(resource) # Role-based analysis role_analysis = {} for resource in resources: if resource.role not in role_analysis: role_analysis[resource.role] = { "count": 0, "total_capacity": 0, "average_utilization": 0, "available_hours": 0, "hourly_cost": 0 } role_data = role_analysis[resource.role] role_data["count"] += 1 role_data["total_capacity"] += resource.effective_hours_per_week role_data["available_hours"] += resource.available_hours role_data["hourly_cost"] += resource.hourly_rate # Calculate averages for roles for role in role_analysis: role_data = role_analysis[role] role_data["average_utilization"] = 1 - (role_data["available_hours"] / max(role_data["total_capacity"], 1)) role_data["average_hourly_rate"] = role_data["hourly_cost"] / role_data["count"] return { "utilization_stats": utilization_stats, "utilization_categories": { k: [{"id": r.id, "name": r.name, "role": r.role, "utilization": r.current_utilization} for r in v] for k, v in utilization_categories.items() }, "role_analysis": role_analysis, "capacity_alerts": _generate_capacity_alerts(utilization_categories) } def analyze_project_capacity_requirements(projects: List[Project]) -> Dict[str, Any]: """Analyze project capacity requirements and gaps.""" project_stats = { "total_projects": len(projects), "active_projects": len([p for p in projects if p.status in ["active", "in_progress"]]), "planned_projects": len([p for p in projects if p.status == "planned"]), "total_estimated_hours": sum(p.adjusted_hours for p in projects), "total_weekly_demand": sum(p.required_hours_per_week for p in projects if p.status != "completed") } # Project priority analysis priority_distribution = {} for priority in ["high", "medium", "low"]: priority_projects = [p for p in projects if p.priority == priority] priority_distribution[priority] = { "count": len(priority_projects), "total_hours": sum(p.adjusted_hours for p in priority_projects), "weekly_demand": sum(p.required_hours_per_week for p in priority_projects if p.status != "completed") } # Capacity gap analysis projects_with_gaps = [p for p in projects if p.capacity_gap > 0 and p.status != "completed"] total_capacity_gap = sum(p.capacity_gap for p in projects_with_gaps) # Skill demand analysis skill_demand = {} for project in projects: if project.status != "completed": for skill, hours in project.skill_requirements.items(): if skill not in skill_demand: skill_demand[skill] = 0 skill_demand[skill] += hours # Sort skills by demand sorted_skill_demand = sorted(skill_demand.items(), key=lambda x: x[1], reverse=True) return { "project_stats": project_stats, "priority_distribution": priority_distribution, "capacity_gaps": { "projects_with_gaps": len(projects_with_gaps), "total_gap_hours_weekly": total_capacity_gap, "gap_projects": [ { "id": p.id, "name": p.name, "priority": p.priority, "gap_hours": p.capacity_gap, "required_skills": p.required_skills } for p in sorted(projects_with_gaps, key=lambda p: p.capacity_gap, reverse=True)[:10] ] }, "skill_demand": dict(sorted_skill_demand[:10]) # Top 10 skills in demand } def optimize_resource_allocation(resources: List[Resource], projects: List[Project]) -> Dict[str, Any]: """Optimize resource allocation across projects.""" optimization_results = { "current_allocation_efficiency": 0.0, "optimization_opportunities": [], "suggested_reallocations": [], "skill_matching_scores": {} } # Calculate current allocation efficiency total_effectiveness = 0 total_allocations = 0 for project in projects: if project.status not in ["completed", "cancelled"] and project.current_allocation: project_effectiveness = 0 for allocation in project.current_allocation: resource_id = allocation.get("resource_id", "") hours = allocation.get("hours_per_week", 0) # Find the resource resource = next((r for r in resources if r.id == resource_id), None) if resource: # Calculate effectiveness for this allocation avg_skill_effectiveness = 0 skill_count = 0 for skill in project.required_skills: if skill in resource.skills: avg_skill_effectiveness += resource.get_skill_effectiveness(skill) skill_count += 1 if skill_count > 0: avg_skill_effectiveness /= skill_count project_effectiveness += avg_skill_effectiveness * hours total_allocations += hours if total_allocations > 0: total_effectiveness += project_effectiveness / total_allocations current_efficiency = total_effectiveness / max(len(projects), 1) optimization_results["current_allocation_efficiency"] = current_efficiency # Find optimization opportunities under_utilized = [r for r in resources if r.current_utilization < UTILIZATION_THRESHOLDS["under_utilized"]] over_allocated_projects = [p for p in projects if p.capacity_gap < 0 and p.status != "completed"] # Generate reallocation suggestions for project in projects: if project.capacity_gap > 0 and project.status != "completed": # Find best-fit under-utilized resources suitable_resources = [] for resource in under_utilized: if resource.can_work_on_project(project.required_skills): skill_match_score = 0 for skill in project.required_skills: if skill in resource.skills: skill_match_score += resource.get_skill_effectiveness(skill) skill_match_score /= max(len(project.required_skills), 1) suitable_resources.append({ "resource": resource, "skill_match_score": skill_match_score, "available_hours": resource.available_hours }) # Sort by skill match and availability suitable_resources.sort(key=lambda x: (x["skill_match_score"], x["available_hours"]), reverse=True) if suitable_resources: optimization_results["suggested_reallocations"].append({ "project_id": project.id, "project_name": project.name, "gap_hours": project.capacity_gap, "recommended_resources": suitable_resources[:3] # Top 3 recommendations }) return optimization_results def simulate_capacity_scenarios(resources: List[Resource], projects: List[Project], scenarios: List[Dict[str, Any]]) -> Dict[str, Any]: """Simulate what-if scenarios for capacity planning.""" scenario_results = {} for scenario in scenarios: scenario_name = scenario.get("name", "Unnamed Scenario") scenario_type = scenario.get("type", "") scenario_params = scenario.get("parameters", {}) # Create copies for simulation sim_resources = [Resource(r.__dict__.copy()) for r in resources] sim_projects = [Project(p.__dict__.copy()) for p in projects] # Apply scenario changes if scenario_type == "add_resource": # Add new resource new_resource_data = scenario_params.get("resource_data", {}) new_resource = Resource(new_resource_data) sim_resources.append(new_resource) elif scenario_type == "remove_resource": # Remove resource resource_id = scenario_params.get("resource_id", "") sim_resources = [r for r in sim_resources if r.id != resource_id] elif scenario_type == "add_project": # Add new project new_project_data = scenario_params.get("project_data", {}) new_project = Project(new_project_data) sim_projects.append(new_project) elif scenario_type == "adjust_utilization": # Adjust resource utilization resource_id = scenario_params.get("resource_id", "") new_utilization = scenario_params.get("new_utilization", 0) for resource in sim_resources: if resource.id == resource_id: resource.current_utilization = new_utilization resource._calculate_effective_capacity() # Analyze scenario results resource_analysis = analyze_resource_utilization(sim_resources) project_analysis = analyze_project_capacity_requirements(sim_projects) scenario_results[scenario_name] = { "scenario_type": scenario_type, "resource_utilization": resource_analysis["utilization_stats"]["overall_utilization"], "total_capacity": resource_analysis["utilization_stats"]["total_capacity"], "capacity_gaps": project_analysis["capacity_gaps"]["total_gap_hours_weekly"], "under_utilized_count": len(resource_analysis["utilization_categories"]["under_utilized"]), "over_utilized_count": len(resource_analysis["utilization_categories"]["over_utilized"]), "cost_impact": _calculate_cost_impact(sim_resources, resources) } return scenario_results def _generate_capacity_alerts(utilization_categories: Dict[str, List[Resource]]) -> List[str]: """Generate capacity-related alerts and warnings.""" alerts = [] critical_resources = utilization_categories.get("critical", []) over_utilized = utilization_categories.get("over_utilized", []) under_utilized = utilization_categories.get("under_utilized", []) if critical_resources: alerts.append(f"CRITICAL: {len(critical_resources)} resources are severely over-allocated (>95%)") if over_utilized: alerts.append(f"WARNING: {len(over_utilized)} resources are over-allocated (85-95%)") if len(under_utilized) > len(critical_resources) + len(over_utilized): alerts.append(f"OPPORTUNITY: {len(under_utilized)} resources are under-utilized (<60%)") return alerts def _calculate_cost_impact(sim_resources: List[Resource], baseline_resources: List[Resource]) -> float: """Calculate cost impact of scenario vs baseline.""" sim_cost = sum(r.hourly_rate * r.effective_hours_per_week for r in sim_resources) baseline_cost = sum(r.hourly_rate * r.effective_hours_per_week for r in baseline_resources) return sim_cost - baseline_cost def generate_capacity_recommendations(analysis_results: Dict[str, Any]) -> List[str]: """Generate actionable capacity management recommendations.""" recommendations = [] # Resource utilization recommendations resource_analysis = analysis_results.get("resource_analysis", {}) utilization_categories = resource_analysis.get("utilization_categories", {}) critical_count = len(utilization_categories.get("critical", [])) over_utilized_count = len(utilization_categories.get("over_utilized", [])) under_utilized_count = len(utilization_categories.get("under_utilized", [])) if critical_count > 0: recommendations.append(f"URGENT: Redistribute workload for {critical_count} critically over-allocated resources to prevent burnout.") if over_utilized_count > 2: recommendations.append(f"Consider hiring or redistributing work - {over_utilized_count} team members are over-allocated.") if under_utilized_count > 0 and critical_count + over_utilized_count > 0: recommendations.append(f"Rebalance allocation - {under_utilized_count} under-utilized resources could help with over-allocated work.") # Project capacity recommendations project_analysis = analysis_results.get("project_analysis", {}) capacity_gaps = project_analysis.get("capacity_gaps", {}) total_gap = capacity_gaps.get("total_gap_hours_weekly", 0) if total_gap > 40: # More than 1 FTE worth of gap recommendations.append(f"Capacity shortfall of {total_gap:.0f} hours/week detected. Consider hiring or timeline adjustments.") # Skill-based recommendations skill_demand = project_analysis.get("skill_demand", {}) if skill_demand: top_skill = list(skill_demand.keys())[0] top_demand = skill_demand[top_skill] recommendations.append(f"High demand for {top_skill} skills ({top_demand} hours). Consider training or specialized hiring.") # Optimization recommendations optimization = analysis_results.get("allocation_optimization", {}) efficiency = optimization.get("current_allocation_efficiency", 0) if efficiency < 0.7: recommendations.append("Low allocation efficiency detected. Review skill-to-project matching and consider reallocation.") return recommendations # --------------------------------------------------------------------------- # Main Analysis Function # --------------------------------------------------------------------------- def analyze_capacity(data: Dict[str, Any]) -> CapacityAnalysisResult: """Perform comprehensive capacity analysis.""" result = CapacityAnalysisResult() try: # Parse resource and project data resource_records = data.get("resources", []) project_records = data.get("projects", []) resources = [Resource(record) for record in resource_records] projects = [Project(record) for record in project_records] if not resources: raise ValueError("No resource data found") # Basic summary result.summary = { "total_resources": len(resources), "total_projects": len(projects), "active_projects": len([p for p in projects if p.status in ["active", "in_progress"]]), "total_capacity_hours": sum(r.effective_hours_per_week for r in resources), "total_demand_hours": sum(p.required_hours_per_week for p in projects if p.status != "completed"), "overall_utilization": sum(r.current_utilization for r in resources) / max(len(resources), 1) } # Resource analysis result.resource_analysis = analyze_resource_utilization(resources) # Project analysis result.project_analysis = analyze_project_capacity_requirements(projects) # Allocation optimization result.allocation_optimization = optimize_resource_allocation(resources, projects) # Scenario analysis (if scenarios provided) scenarios = data.get("scenarios", []) if scenarios: result.scenario_analysis = simulate_capacity_scenarios(resources, projects, scenarios) # Generate recommendations analysis_data = { "resource_analysis": result.resource_analysis, "project_analysis": result.project_analysis, "allocation_optimization": result.allocation_optimization } result.recommendations = generate_capacity_recommendations(analysis_data) except Exception as e: result.summary = {"error": str(e)} return result # --------------------------------------------------------------------------- # Output Formatting # --------------------------------------------------------------------------- def format_text_output(result: CapacityAnalysisResult) -> str: """Format analysis results as readable text report.""" lines = [] lines.append("="*60) lines.append("RESOURCE CAPACITY PLANNING REPORT") lines.append("="*60) lines.append("") if "error" in result.summary: lines.append(f"ERROR: {result.summary['error']}") return "\n".join(lines) # Executive Summary summary = result.summary lines.append("CAPACITY OVERVIEW") lines.append("-"*30) lines.append(f"Total Resources: {summary['total_resources']}") lines.append(f"Total Projects: {summary['total_projects']} ({summary['active_projects']} active)") lines.append(f"Capacity vs Demand: {summary['total_capacity_hours']:.0f}h vs {summary['total_demand_hours']:.0f}h per week") lines.append(f"Overall Utilization: {summary['overall_utilization']:.1%}") lines.append("") # Resource Utilization resource_analysis = result.resource_analysis lines.append("RESOURCE UTILIZATION ANALYSIS") lines.append("-"*30) utilization_categories = resource_analysis.get("utilization_categories", {}) for category, resources in utilization_categories.items(): if resources: lines.append(f"{category.replace('_', ' ').title()}: {len(resources)} resources") for resource in resources[:3]: # Show top 3 lines.append(f" - {resource['name']} ({resource['role']}): {resource['utilization']:.1%}") if len(resources) > 3: lines.append(f" ... and {len(resources) - 3} more") lines.append("") # Capacity Alerts alerts = resource_analysis.get("capacity_alerts", []) if alerts: lines.append("CAPACITY ALERTS") lines.append("-"*30) for alert in alerts: lines.append(f"⚠️ {alert}") lines.append("") # Project Capacity Gaps project_analysis = result.project_analysis capacity_gaps = project_analysis.get("capacity_gaps", {}) lines.append("PROJECT CAPACITY GAPS") lines.append("-"*30) lines.append(f"Projects with gaps: {capacity_gaps.get('projects_with_gaps', 0)}") lines.append(f"Total gap: {capacity_gaps.get('total_gap_hours_weekly', 0):.0f} hours/week") gap_projects = capacity_gaps.get("gap_projects", []) if gap_projects: lines.append("Top projects needing resources:") for project in gap_projects[:5]: lines.append(f" - {project['name']} ({project['priority']}): {project['gap_hours']:.0f}h/week gap") lines.append("") # Skill Demand skill_demand = project_analysis.get("skill_demand", {}) if skill_demand: lines.append("TOP SKILL DEMANDS") lines.append("-"*30) for skill, hours in list(skill_demand.items())[:5]: lines.append(f"{skill}: {hours} hours needed") lines.append("") # Optimization Suggestions optimization = result.allocation_optimization suggested_reallocations = optimization.get("suggested_reallocations", []) if suggested_reallocations: lines.append("RESOURCE REALLOCATION SUGGESTIONS") lines.append("-"*30) for suggestion in suggested_reallocations[:3]: lines.append(f"Project: {suggestion['project_name']}") lines.append(f" Gap: {suggestion['gap_hours']:.0f} hours/week") recommended = suggestion.get("recommended_resources", []) if recommended: best_match = recommended[0] resource_info = best_match["resource"] lines.append(f" Best fit: {resource_info.name} ({resource_info.role})") lines.append(f" Skill match: {best_match['skill_match_score']:.1%}") lines.append(f" Available: {best_match['available_hours']:.0f}h/week") lines.append("") # Scenario Analysis scenario_analysis = result.scenario_analysis if scenario_analysis: lines.append("SCENARIO ANALYSIS") lines.append("-"*30) for scenario_name, results in scenario_analysis.items(): lines.append(f"{scenario_name}:") lines.append(f" Utilization: {results['resource_utilization']:.1%}") lines.append(f" Capacity gaps: {results['capacity_gaps']:.0f}h/week") lines.append(f" Cost impact: ${results['cost_impact']:.0f}/week") lines.append("") # Recommendations if result.recommendations: lines.append("RECOMMENDATIONS") lines.append("-"*30) for i, rec in enumerate(result.recommendations, 1): lines.append(f"{i}. {rec}") return "\n".join(lines) def format_json_output(result: CapacityAnalysisResult) -> Dict[str, Any]: """Format analysis results as JSON.""" # Helper function to serialize Resource objects def serialize_resource(resource): if hasattr(resource, 'id'): return { "id": resource.id, "name": resource.name, "role": resource.role, "utilization": resource.current_utilization, "available_hours": resource.available_hours, "hourly_rate": resource.hourly_rate } return resource # Deep copy and clean up the result serialized_result = { "summary": result.summary, "resource_analysis": result.resource_analysis, "project_analysis": result.project_analysis, "allocation_optimization": result.allocation_optimization, "scenario_analysis": result.scenario_analysis, "recommendations": result.recommendations } # Handle Resource objects in optimization suggestions if "suggested_reallocations" in serialized_result["allocation_optimization"]: for suggestion in serialized_result["allocation_optimization"]["suggested_reallocations"]: if "recommended_resources" in suggestion: for rec in suggestion["recommended_resources"]: if "resource" in rec: rec["resource"] = serialize_resource(rec["resource"]) return serialized_result # --------------------------------------------------------------------------- # CLI Interface # --------------------------------------------------------------------------- def main() -> int: """Main CLI entry point.""" parser = argparse.ArgumentParser( description="Analyze resource capacity and allocation across project portfolio" ) parser.add_argument( "data_file", help="JSON file containing resource and project capacity data" ) parser.add_argument( "--format", choices=["text", "json"], default="text", help="Output format (default: text)" ) args = parser.parse_args() try: # Load and validate data with open(args.data_file, 'r') as f: data = json.load(f) # Perform analysis result = analyze_capacity(data) # Output results if args.format == "json": output = format_json_output(result) print(json.dumps(output, indent=2)) else: output = format_text_output(result) print(output) return 0 except FileNotFoundError: print(f"Error: File '{args.data_file}' not found", file=sys.stderr) return 1 except json.JSONDecodeError as e: print(f"Error: Invalid JSON in '{args.data_file}': {e}", file=sys.stderr) return 1 except Exception as e: print(f"Error: {e}", file=sys.stderr) return 1 if __name__ == "__main__": sys.exit(main()) FILE:scripts/risk_matrix_analyzer.py #!/usr/bin/env python3 """ Risk Matrix Analyzer Builds probability/impact matrices, calculates risk scores, suggests mitigation strategies based on risk category, and tracks risk trends over time. Provides comprehensive risk assessment and prioritization for project portfolios. Usage: python risk_matrix_analyzer.py risk_data.json python risk_matrix_analyzer.py risk_data.json --format json """ import argparse import json import statistics import sys from datetime import datetime, timedelta from typing import Any, Dict, List, Optional, Tuple, Union # --------------------------------------------------------------------------- # Risk Assessment Configuration # --------------------------------------------------------------------------- RISK_CATEGORIES = { "technical": { "weight": 1.2, "description": "Technology, architecture, integration risks", "mitigation_strategies": [ "Proof of concept development", "Technical spike implementation", "Expert consultation", "Alternative technology evaluation", "Incremental development approach" ] }, "resource": { "weight": 1.1, "description": "Team capacity, skills, availability risks", "mitigation_strategies": [ "Resource planning and buffer allocation", "Skill development and training", "Cross-training and knowledge sharing", "Contractor or consultant engagement", "Timeline adjustment for capacity" ] }, "schedule": { "weight": 1.0, "description": "Timeline, deadline, dependency risks", "mitigation_strategies": [ "Critical path analysis and optimization", "Buffer time allocation", "Dependency management and coordination", "Scope prioritization and phasing", "Parallel work streams where possible" ] }, "business": { "weight": 1.3, "description": "Market, customer, competitive risks", "mitigation_strategies": [ "Market research and validation", "Customer feedback integration", "Competitive analysis monitoring", "Stakeholder engagement strategy", "Business case validation checkpoints" ] }, "financial": { "weight": 1.4, "description": "Budget, ROI, cost overrun risks", "mitigation_strategies": [ "Detailed cost estimation and tracking", "Budget reserve allocation", "Regular financial checkpoint reviews", "Cost-benefit analysis updates", "Alternative funding source identification" ] }, "regulatory": { "weight": 1.5, "description": "Compliance, legal, governance risks", "mitigation_strategies": [ "Legal review and approval processes", "Compliance audit preparation", "Regulatory body engagement", "Documentation and audit trail maintenance", "External legal counsel consultation" ] }, "external": { "weight": 1.0, "description": "Vendor, partner, environmental risks", "mitigation_strategies": [ "Vendor assessment and backup options", "Contract negotiation and SLA definition", "Environmental monitoring and adaptation", "Partner relationship management", "External dependency tracking" ] } } PROBABILITY_LEVELS = { 1: {"label": "Very Low", "range": "0-10%", "description": "Highly unlikely to occur"}, 2: {"label": "Low", "range": "11-30%", "description": "Unlikely but possible"}, 3: {"label": "Medium", "range": "31-60%", "description": "Moderate likelihood"}, 4: {"label": "High", "range": "61-85%", "description": "Likely to occur"}, 5: {"label": "Very High", "range": "86-100%", "description": "Almost certain to occur"} } IMPACT_LEVELS = { 1: {"label": "Very Low", "description": "Minimal impact on project success"}, 2: {"label": "Low", "description": "Minor delays or cost increases"}, 3: {"label": "Medium", "description": "Significant impact on timeline/budget"}, 4: {"label": "High", "description": "Major project disruption"}, 5: {"label": "Very High", "description": "Project failure or critical compromise"} } RISK_TOLERANCE_THRESHOLDS = { "low": 8, # Risk score <= 8: Accept "medium": 15, # Risk score 9-15: Monitor "high": 20, # Risk score 16-20: Mitigate "critical": 25 # Risk score >20: Urgent action } MITIGATION_STRATEGIES = { "accept": "Monitor risk without active mitigation", "avoid": "Eliminate risk through scope or approach changes", "mitigate": "Reduce probability or impact through proactive measures", "transfer": "Share or transfer risk to third parties", "contingency": "Prepare response plan for risk occurrence" } # --------------------------------------------------------------------------- # Data Models # --------------------------------------------------------------------------- class Risk: """Represents a single project risk with assessment and mitigation data.""" def __init__(self, data: Dict[str, Any]): self.id: str = data.get("id", "") self.title: str = data.get("title", "") self.description: str = data.get("description", "") self.category: str = data.get("category", "technical").lower() self.probability: int = max(1, min(5, data.get("probability", 3))) self.impact: int = max(1, min(5, data.get("impact", 3))) self.owner: str = data.get("owner", "") self.status: str = data.get("status", "open").lower() self.identified_date: str = data.get("identified_date", "") self.target_resolution: Optional[str] = data.get("target_resolution") self.mitigation_strategy: str = data.get("mitigation_strategy", "").lower() self.mitigation_actions: List[str] = data.get("mitigation_actions", []) self.cost_impact: Optional[float] = data.get("cost_impact") self.schedule_impact: Optional[int] = data.get("schedule_impact_days") # Calculate derived metrics self._calculate_risk_score() self._determine_risk_level() self._suggest_mitigation_approach() def _calculate_risk_score(self): """Calculate weighted risk score based on category, probability, and impact.""" base_score = self.probability * self.impact category_weight = RISK_CATEGORIES.get(self.category, {}).get("weight", 1.0) self.risk_score = base_score * category_weight def _determine_risk_level(self): """Determine risk level based on score thresholds.""" if self.risk_score <= RISK_TOLERANCE_THRESHOLDS["low"]: self.risk_level = "low" elif self.risk_score <= RISK_TOLERANCE_THRESHOLDS["medium"]: self.risk_level = "medium" elif self.risk_score <= RISK_TOLERANCE_THRESHOLDS["high"]: self.risk_level = "high" else: self.risk_level = "critical" def _suggest_mitigation_approach(self): """Suggest mitigation approach based on risk characteristics.""" if self.risk_level == "low": self.suggested_approach = "accept" elif self.probability >= 4 and self.impact <= 2: self.suggested_approach = "mitigate" # Likely but low impact elif self.probability <= 2 and self.impact >= 4: self.suggested_approach = "contingency" # Unlikely but high impact elif self.impact >= 4: self.suggested_approach = "avoid" # High impact risks else: self.suggested_approach = "mitigate" @property def is_active(self) -> bool: return self.status.lower() in ["open", "identified", "monitoring", "mitigating"] @property def is_overdue(self) -> bool: if not self.target_resolution: return False try: target_date = datetime.strptime(self.target_resolution, "%Y-%m-%d") return datetime.now() > target_date and self.is_active except ValueError: return False class RiskAnalysisResult: """Complete risk analysis results.""" def __init__(self): self.summary: Dict[str, Any] = {} self.risk_matrix: Dict[str, Any] = {} self.category_analysis: Dict[str, Any] = {} self.mitigation_analysis: Dict[str, Any] = {} self.trend_analysis: Dict[str, Any] = {} self.recommendations: List[str] = [] # --------------------------------------------------------------------------- # Risk Analysis Functions # --------------------------------------------------------------------------- def build_risk_matrix(risks: List[Risk]) -> Dict[str, Any]: """Build probability/impact risk matrix with risk distribution.""" matrix = {} risk_distribution = {} # Initialize matrix for prob in range(1, 6): matrix[prob] = {} for impact in range(1, 6): matrix[prob][impact] = [] # Populate matrix with risks for risk in risks: if risk.is_active: matrix[risk.probability][risk.impact].append({ "id": risk.id, "title": risk.title, "risk_score": risk.risk_score, "category": risk.category }) # Calculate distribution statistics total_risks = len([r for r in risks if r.is_active]) risk_distribution = { "critical": len([r for r in risks if r.is_active and r.risk_level == "critical"]), "high": len([r for r in risks if r.is_active and r.risk_level == "high"]), "medium": len([r for r in risks if r.is_active and r.risk_level == "medium"]), "low": len([r for r in risks if r.is_active and r.risk_level == "low"]) } # Calculate risk exposure total_score = sum(r.risk_score for r in risks if r.is_active) average_score = total_score / max(total_risks, 1) return { "matrix": matrix, "distribution": risk_distribution, "total_risks": total_risks, "total_risk_score": total_score, "average_risk_score": average_score, "risk_exposure_level": _classify_risk_exposure(average_score) } def analyze_risk_categories(risks: List[Risk]) -> Dict[str, Any]: """Analyze risks by category with detailed statistics.""" category_stats = {} active_risks = [r for r in risks if r.is_active] for category, config in RISK_CATEGORIES.items(): category_risks = [r for r in active_risks if r.category == category] if category_risks: risk_scores = [r.risk_score for r in category_risks] category_stats[category] = { "count": len(category_risks), "total_score": sum(risk_scores), "average_score": statistics.mean(risk_scores), "max_score": max(risk_scores), "risk_level_distribution": _get_risk_level_distribution(category_risks), "top_risks": sorted(category_risks, key=lambda r: r.risk_score, reverse=True)[:3], "mitigation_coverage": _calculate_mitigation_coverage(category_risks), "suggested_strategies": config["mitigation_strategies"][:3] } else: category_stats[category] = { "count": 0, "total_score": 0, "average_score": 0, "risk_level_distribution": {}, "mitigation_coverage": 0 } # Identify highest risk categories sorted_categories = sorted( [(cat, stats) for cat, stats in category_stats.items() if stats["count"] > 0], key=lambda x: x[1]["total_score"], reverse=True ) return { "category_statistics": category_stats, "highest_risk_categories": [cat for cat, _ in sorted_categories[:3]], "category_concentration": len([c for c in category_stats if category_stats[c]["count"] > 0]) } def analyze_mitigation_effectiveness(risks: List[Risk]) -> Dict[str, Any]: """Analyze mitigation strategy effectiveness and coverage.""" active_risks = [r for r in risks if r.is_active] # Mitigation strategy distribution strategy_distribution = {} for strategy in MITIGATION_STRATEGIES.keys(): strategy_risks = [r for r in active_risks if r.mitigation_strategy == strategy] if strategy_risks: strategy_distribution[strategy] = { "count": len(strategy_risks), "average_risk_score": statistics.mean([r.risk_score for r in strategy_risks]), "risk_levels": _get_risk_level_distribution(strategy_risks) } # Mitigation coverage analysis risks_with_mitigation = [r for r in active_risks if r.mitigation_actions] mitigation_coverage = len(risks_with_mitigation) / max(len(active_risks), 1) # Action item analysis total_actions = sum(len(r.mitigation_actions) for r in active_risks) average_actions_per_risk = total_actions / max(len(active_risks), 1) # Overdue mitigation analysis overdue_risks = [r for r in active_risks if r.is_overdue] overdue_rate = len(overdue_risks) / max(len(active_risks), 1) return { "strategy_distribution": strategy_distribution, "mitigation_coverage": mitigation_coverage, "average_actions_per_risk": average_actions_per_risk, "overdue_mitigation_count": len(overdue_risks), "overdue_rate": overdue_rate, "top_overdue_risks": sorted(overdue_risks, key=lambda r: r.risk_score, reverse=True)[:5] } def analyze_risk_trends(current_risks: List[Risk], historical_data: Optional[List[Dict]] = None) -> Dict[str, Any]: """Analyze risk trends over time if historical data is available.""" if not historical_data: return { "trend_analysis_available": False, "message": "Historical data required for trend analysis" } # Simple trend analysis based on current vs. historical risk levels current_total_score = sum(r.risk_score for r in current_risks if r.is_active) current_risk_count = len([r for r in current_risks if r.is_active]) # This is a simplified implementation - in practice, you'd track risks over time trend_data = { "trend_analysis_available": True, "current_total_risk_score": current_total_score, "current_active_risks": current_risk_count, "risk_velocity": { "new_risks_rate": "Calculate from historical data", "resolution_rate": "Calculate from historical data", "escalation_rate": "Calculate from historical data" } } return trend_data def generate_risk_recommendations(risks: List[Risk], analysis_results: Dict[str, Any]) -> List[str]: """Generate actionable risk management recommendations.""" recommendations = [] # Critical risk recommendations critical_risks = [r for r in risks if r.is_active and r.risk_level == "critical"] if critical_risks: recommendations.append(f"URGENT: Address {len(critical_risks)} critical risks immediately. These require executive attention and dedicated resources.") for risk in critical_risks[:3]: # Top 3 critical risks recommendations.append(f"Critical Risk - {risk.title}: Implement {risk.suggested_approach} strategy within 48 hours.") # High-concentration category recommendations category_analysis = analysis_results.get("category_analysis", {}) highest_categories = category_analysis.get("highest_risk_categories", []) if highest_categories: top_category = highest_categories[0] recommendations.append(f"Focus mitigation efforts on {top_category} risks - highest concentration of risk exposure.") # Mitigation coverage recommendations mitigation_analysis = analysis_results.get("mitigation_analysis", {}) coverage = mitigation_analysis.get("mitigation_coverage", 0) if coverage < 0.7: recommendations.append("Improve mitigation coverage - less than 70% of risks have defined mitigation actions.") overdue_rate = mitigation_analysis.get("overdue_rate", 0) if overdue_rate > 0.2: recommendations.append("Address overdue mitigation actions - more than 20% of risks are past their target resolution date.") # Risk matrix recommendations matrix_analysis = analysis_results.get("risk_matrix", {}) avg_score = matrix_analysis.get("average_risk_score", 0) if avg_score > 15: recommendations.append("Portfolio risk exposure is high. Consider scope reduction or additional risk mitigation investments.") elif avg_score < 8: recommendations.append("Risk exposure is well-managed. Consider taking on additional strategic initiatives.") return recommendations # --------------------------------------------------------------------------- # Utility Functions # --------------------------------------------------------------------------- def _classify_risk_exposure(average_score: float) -> str: """Classify overall portfolio risk exposure level.""" if average_score > 18: return "very_high" elif average_score > 15: return "high" elif average_score > 12: return "medium" elif average_score > 8: return "low" else: return "very_low" def _get_risk_level_distribution(risks: List[Risk]) -> Dict[str, int]: """Get distribution of risk levels for a set of risks.""" distribution = {"critical": 0, "high": 0, "medium": 0, "low": 0} for risk in risks: distribution[risk.risk_level] += 1 return distribution def _calculate_mitigation_coverage(risks: List[Risk]) -> float: """Calculate percentage of risks with defined mitigation actions.""" if not risks: return 0.0 risks_with_mitigation = sum(1 for r in risks if r.mitigation_actions) return risks_with_mitigation / len(risks) # --------------------------------------------------------------------------- # Main Analysis Function # --------------------------------------------------------------------------- def analyze_risks(data: Dict[str, Any]) -> RiskAnalysisResult: """Perform comprehensive risk analysis.""" result = RiskAnalysisResult() try: # Parse risk data risk_records = data.get("risks", []) risks = [Risk(record) for record in risk_records] if not risks: raise ValueError("No risk data found") # Basic summary active_risks = [r for r in risks if r.is_active] result.summary = { "total_risks": len(risks), "active_risks": len(active_risks), "closed_risks": len(risks) - len(active_risks), "critical_risks": len([r for r in active_risks if r.risk_level == "critical"]), "high_risks": len([r for r in active_risks if r.risk_level == "high"]), "total_risk_exposure": sum(r.risk_score for r in active_risks), "average_risk_score": sum(r.risk_score for r in active_risks) / max(len(active_risks), 1), "overdue_risks": len([r for r in active_risks if r.is_overdue]) } # Risk matrix analysis result.risk_matrix = build_risk_matrix(risks) # Category analysis result.category_analysis = analyze_risk_categories(risks) # Mitigation analysis result.mitigation_analysis = analyze_mitigation_effectiveness(risks) # Trend analysis (simplified without historical data) result.trend_analysis = analyze_risk_trends(risks, data.get("historical_data")) # Generate recommendations analysis_data = { "category_analysis": result.category_analysis, "mitigation_analysis": result.mitigation_analysis, "risk_matrix": result.risk_matrix } result.recommendations = generate_risk_recommendations(risks, analysis_data) except Exception as e: result.summary = {"error": str(e)} return result # --------------------------------------------------------------------------- # Output Formatting # --------------------------------------------------------------------------- def format_text_output(result: RiskAnalysisResult) -> str: """Format analysis results as readable text report.""" lines = [] lines.append("="*60) lines.append("RISK MATRIX ANALYSIS REPORT") lines.append("="*60) lines.append("") if "error" in result.summary: lines.append(f"ERROR: {result.summary['error']}") return "\n".join(lines) # Executive Summary summary = result.summary lines.append("EXECUTIVE SUMMARY") lines.append("-"*30) lines.append(f"Total Risks: {summary['total_risks']} ({summary['active_risks']} active)") lines.append(f"Risk Exposure: {summary['total_risk_exposure']:.1f} points (avg: {summary['average_risk_score']:.1f})") lines.append(f"Critical/High Risks: {summary['critical_risks']}/{summary['high_risks']}") lines.append(f"Overdue Mitigations: {summary['overdue_risks']}") lines.append("") # Risk Distribution matrix = result.risk_matrix lines.append("RISK LEVEL DISTRIBUTION") lines.append("-"*30) distribution = matrix.get("distribution", {}) for level in ["critical", "high", "medium", "low"]: count = distribution.get(level, 0) percentage = (count / max(summary["active_risks"], 1)) * 100 lines.append(f"{level.title()}: {count} ({percentage:.1f}%)") lines.append("") # Risk Matrix Visualization lines.append("RISK MATRIX (Probability vs Impact)") lines.append("-"*50) lines.append(" 1 2 3 4 5 (Impact)") matrix_data = matrix.get("matrix", {}) for prob in range(5, 0, -1): line = f"{prob} " for impact in range(1, 6): risk_count = len(matrix_data.get(prob, {}).get(impact, [])) line += f" [{risk_count:2}]" lines.append(line) lines.append("(P)") lines.append("") # Category Analysis category_analysis = result.category_analysis lines.append("RISK BY CATEGORY") lines.append("-"*30) category_stats = category_analysis.get("category_statistics", {}) for category, stats in category_stats.items(): if stats["count"] > 0: lines.append(f"{category.title()}: {stats['count']} risks, " f"avg score: {stats['average_score']:.1f}, " f"total exposure: {stats['total_score']:.1f}") lines.append("") # Mitigation Analysis mitigation = result.mitigation_analysis lines.append("MITIGATION EFFECTIVENESS") lines.append("-"*30) lines.append(f"Mitigation Coverage: {mitigation.get('mitigation_coverage', 0):.1%}") lines.append(f"Average Actions per Risk: {mitigation.get('average_actions_per_risk', 0):.1f}") lines.append(f"Overdue Mitigations: {mitigation.get('overdue_mitigation_count', 0)} " f"({mitigation.get('overdue_rate', 0):.1%})") lines.append("") # Top Risks lines.append("TOP RISKS REQUIRING ATTENTION") lines.append("-"*30) # Find top risks across all categories all_risks = [] for category_stats in category_stats.values(): if "top_risks" in category_stats: all_risks.extend(category_stats["top_risks"]) top_risks = sorted(all_risks, key=lambda r: r.risk_score, reverse=True)[:5] for i, risk in enumerate(top_risks, 1): lines.append(f"{i}. {risk.title} (Score: {risk.risk_score:.1f}, Level: {risk.risk_level.title()})") lines.append(f" Category: {risk.category.title()}, Strategy: {risk.suggested_approach.title()}") lines.append("") # Recommendations if result.recommendations: lines.append("RECOMMENDATIONS") lines.append("-"*30) for i, rec in enumerate(result.recommendations, 1): lines.append(f"{i}. {rec}") return "\n".join(lines) def format_json_output(result: RiskAnalysisResult) -> Dict[str, Any]: """Format analysis results as JSON.""" # Convert Risk objects to dictionaries for JSON serialization def serialize_risks(obj): if isinstance(obj, list): return [serialize_risks(item) for item in obj] elif hasattr(obj, 'id') and hasattr(obj, 'title'): # This is a Risk object return { "id": obj.id, "title": obj.title, "risk_score": obj.risk_score, "risk_level": obj.risk_level, "category": obj.category, "probability": obj.probability, "impact": obj.impact, "status": obj.status } elif isinstance(obj, dict): return {key: serialize_risks(value) for key, value in obj.items()} else: return obj # Deep copy and serialize all risk objects recursively return serialize_risks({ "summary": result.summary, "risk_matrix": result.risk_matrix, "category_analysis": result.category_analysis, "mitigation_analysis": result.mitigation_analysis, "trend_analysis": result.trend_analysis, "recommendations": result.recommendations }) # --------------------------------------------------------------------------- # CLI Interface # --------------------------------------------------------------------------- def main() -> int: """Main CLI entry point.""" parser = argparse.ArgumentParser( description="Analyze project risks with probability/impact matrix and mitigation recommendations" ) parser.add_argument( "data_file", help="JSON file containing risk register data" ) parser.add_argument( "--format", choices=["text", "json"], default="text", help="Output format (default: text)" ) args = parser.parse_args() try: # Load and validate data with open(args.data_file, 'r') as f: data = json.load(f) # Perform analysis result = analyze_risks(data) # Output results if args.format == "json": output = format_json_output(result) print(json.dumps(output, indent=2)) else: output = format_text_output(result) print(output) return 0 except FileNotFoundError: print(f"Error: File '{args.data_file}' not found", file=sys.stderr) return 1 except json.JSONDecodeError as e: print(f"Error: Invalid JSON in '{args.data_file}': {e}", file=sys.stderr) return 1 except Exception as e: print(f"Error: {e}", file=sys.stderr) return 1 if __name__ == "__main__": sys.exit(main())

senior-pm

Comments (0)