gap-analysis

name	gap-analysis
description	Identify differences between current state and desired future state. Analyze gaps in capabilities, processes, skills, and technology to plan improvements and investments.

Gap Analysis

Overview

Gap analysis systematically compares current capabilities with desired future state, revealing what needs to change and what investments are required.

When to Use

• Strategic planning and goal setting
• Technology modernization assessment
• Process improvement initiatives
• Skills and training planning
• System evaluation and selection
• Organizational change planning
• Capability building programs

Instructions

1. Gap Identification Framework

# Systematic gap identification

class GapAnalysis:
    GAP_CATEGORIES = {
        'Business Capability': 'Functions organization can perform',
        'Process': 'How work gets done',
        'Technology': 'Tools and systems available',
        'Skills': 'Knowledge and expertise',
        'Data': 'Information available',
        'People/Culture': 'Team composition and mindset',
        'Organization': 'Structure and roles',
        'Metrics': 'Ability to measure performance'
    }

    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'

2. Gap Analysis Template

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:

## Category: Technology

Gap 1: Cloud Infrastructure
  Current:   
       
   
    
   
      
   

   
     
     
   
    
   
      
   

  
    
       
   
    
      
     
   




   
     
      
   
       
         
    
   

   
      
      
   
      
     
    
   




  
     
     
   
    
      
    
   

  
    
     
   
    
      
   
   





       
          
        


            
       
       





    
    
    
    


    
    
    
    


  

   
    
     
     

   
     
     
     

  
     
     
    

  
     
     
    





      
      
    
    


      
    
      
    

    

3. Gap Closure Planning

// 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) {
    
     {
      : ,
      : [
        {
          : ,
          : [, ],
          : 
        },
        {
          : ,
          : [, , ],
          : 
        },
        {
          : ,
          : [, , ],
          : gap. + 
        },
        {
          : ,
          : [, , ],
          : 
        }
      ]
    };
  }

  () {
    
     {
      : ,
      : [
        {
          : ,
          : [, , ],
          : 
        },
        {
          : ,
          : [, , ],
          : gap. + 
        },
        {
          : ,
          : [, , ],
          : 
        }
      ]
    };
  }

  () {
     [
      { : , :  },
      { : , :  },
      { : , :  },
      { : , :  }
    ];
  }
}

4. Communication & Tracking

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
  -   




  
     
    
        
       

   
    
       
    
        

  
   
   
       
       

Best Practices

✅ DO

• Compare current to clearly defined future state
• Include all relevant capability areas
• Involve stakeholders in gap identification
• Prioritize by value and effort
• Create detailed closure plans
• Track progress to closure
• Document gap analysis findings
• Review and update analysis quarterly
• Link gaps to business strategy
• Communicate findings transparently

❌ DON'T

• Skip current state assessment
• Create vague future state
• Identify gaps without solutions
• Ignore implementation effort
• Plan all gaps in parallel
• Forget about dependencies
• Ignore resource constraints
• Hide difficult findings
• Plan for 100% effort allocation
• Forget about change management

Gap Analysis Tips

• Involve people doing the work
• Be realistic about effort estimates
• Start with highest-value gaps
• Build dependencies and sequencing
• Monitor progress weekly