undefined

def identify_gaps(self, current_state, future_state):
    """Compare current vs desired and find gaps"""
    gaps = []

    for capability in future_state['capabilities']:
        current_capability = self.find_capability(
            capability['name'],
            current_state['capabilities']
        )

        if current_capability is None:
            gaps.append({
                'capability': capability['name'],
                'gap_type': 'Missing',
                'description': f"Organization lacks {capability['name']}",
                'importance': capability['importance'],
                'impact': 'High' if capability['importance'] == 'Critical' else 'Medium'
            })
        elif current_capability['maturity'] < capability['target_maturity']:
            gaps.append({
                'capability': capability['name'],
                'gap_type': 'Maturity',
                'current_maturity': current_capability['maturity'],
                'target_maturity': capability['target_maturity'],
                'gap_size': capability['target_maturity'] - current_capability['maturity'],
                'importance': capability['importance'],
                'impact': 'Medium'
            })

    return gaps

def prioritize_gaps(self, gaps):
    """Rank gaps by importance and effort"""
    scored_gaps = []

    for gap in gaps:
        importance = self.score_importance(gap)
        effort = self.estimate_effort(gap)
        value = importance / effort if effort > 0 else 0

        scored_gaps.append({
            **gap,
            'importance_score': importance,
            'effort_score': effort,
            'value_score': value,
            'priority': self.assign_priority(value)
        })

    return sorted(scored_gaps, key=lambda x: x['value_score'], reverse=True)

def score_importance(self, gap):
    """Score how important gap is"""
    if gap['importance'] == 'Critical':
        return 10
    elif gap['importance'] == 'High':
        return 7
    else:
        return 4

def estimate_effort(self, gap):
    """Estimate effort to close gap"""
    # Returns 1-10 scale
    return gap.get('effort_estimate', 5)

def assign_priority(self, value_score):
    """Assign priority based on value"""
    if value_score > 2:
        return 'High'
    elif value_score > 1:
        return 'Medium'
    else:
        return 'Low'

undefined

Gap Analysis Report:

Organization: Customer Analytics Platform
Analysis Date: January 2025
Prepared For: Executive Team

---

Executive Summary:

Current State: Legacy on-premise system with manual processes
Future State: Cloud-native platform with real-time analytics
Gap Magnitude: Significant

Key Findings:
  - 7 critical capability gaps
  - Estimated investment: $500K - $750K
  - Timeline: 12-18 months
  - Primary gaps: Technology, Process, Skills

---

Detailed Gap Analysis:

undefined

// Create action plans to close gaps

class GapClosurePlanning {
  createClosurePlan(gap) {
    return {
      gap_id: gap.id,
      gap_description: gap.description,
      target_state: gap.target_state,

      approach: gap.gap_type === 'Maturity'
        ? this.createMaturityPlan(gap)
        : this.createCapabilityPlan(gap),

      timeline: {
        start_date: gap.start_date,
        target_completion: gap.target_date,
        duration_weeks: Math.ceil(gap.effort_estimate),
        milestones: this.defineMilestones(gap)
      },

      resources: {
        people: gap.required_staff,
        budget: gap.estimated_cost,
        tools: gap.required_tools
      },

      success_criteria: gap.success_metrics,

      risks: this.identifyClosureRisks(gap),

      dependencies: gap.dependencies
    };
  }

  createMaturityPlan(gap) {
    // Plan for improving existing capability
    return {
      strategy: 'Improve capability maturity',
      phases: [
        {
          phase: 'Assess Current',
          activities: ['Document current state', 'Identify improvement areas'],
          duration: '2 weeks'
        },
        {
          phase: 'Plan Improvements',
          activities: ['Define target maturity', 'Create roadmap', 'Allocate resources'],
          duration: '2 weeks'
        },
        {
          phase: 'Implement',
          activities: ['Execute improvement', 'Training', 'Process changes'],
          duration: gap.effort_estimate + ' weeks'
        },
        {
          phase: 'Validate',
          activities: ['Measure against targets', 'Validate maturity', 'Document learnings'],
          duration: '2 weeks'
        }
      ]
    };
  }

  createCapabilityPlan(gap) {
    // Plan for building new capability
    return {
      strategy: 'Build new capability',
      phases: [
        {
          phase: 'Design',
          activities: ['Define requirements', 'Design solution', 'Get approvals'],
          duration: '4 weeks'
        },
        {
          phase: 'Build',
          activities: ['Develop', 'Test', 'Integrate'],
          duration: gap.effort_estimate + ' weeks'
        },
        {
          phase: 'Deploy',
          activities: ['Pilot', 'Roll out', 'Support transition'],
          duration: '4 weeks'
        }
      ]
    };
  }

  defineMilestones(gap) {
    return [
      { name: 'Gap closure initiated', date_offset: 'Week 0' },
      { name: 'First deliverable', date_offset: `Week ${Math.ceil(gap.effort_estimate / 3)}` },
      { name: 'Mid-point review', date_offset: `Week ${Math.ceil(gap.effort_estimate / 2)}` },
      { name: 'Final validation', date_offset: `Week ${gap.effort_estimate}` }
    ];
  }
}

Gap Analysis Communication:

Stakeholder Updates:

Executive Summary (1 page):
  - What gaps exist?
  - Why do they matter?
  - What's the investment?
  - When will we close them?

Detailed Report (10 pages):
  - Gap identification methodology
  - Gap descriptions and impacts
  - Priority and sequencing
  - Detailed closure plans
  - Risk assessment

Team Briefing (30 min):
  - Overview of gaps
  - Impact on team
  - Their role in closure
  - Timeline and changes

---

Tracking Dashboard:

Gap 1: Cloud Infrastructure
  Status: In Progress (40%)
  Timeline: On track
  Budget: On budget ($200K allocated, $80K spent)
  Next Milestone: Infrastructure provisioning (due Feb 15)

Gap 2: Cloud Engineering Skills
  Status: Not started
  Timeline: At risk (delayed by hiring)
  Budget: On budget
  Next Milestone: 2nd engineer hire (due Feb 28)

Gap 3: Data Governance
  Status: Completed
  Timeline: Complete
  Budget: Under budget ($18K vs $20K)
  Business Impact: 30% improvement in data quality