Project Estimation Uitdagingen: Onzekerheid Beheren in Softwareontwikkeling

// Wat we dachten:
"We kunnen dit in 3 maanden doen"

// Wat er werkelijk gebeurde:
const actualTime = 8; // maanden
const estimatedTime = 3; // maanden
const accuracy = (estimatedTime / actualTime) * 100; // 37.5% accurate

// Three-point estimation implementatie
interface EstimationPoint {
  optimistic: number;    // Best case scenario
  mostLikely: number;   // Most probable scenario
  pessimistic: number;   // Worst case scenario
}

interface TaskEstimation {
  taskId: string;
  description: string;
  estimation: EstimationPoint;
  confidence: number;
  assumptions: string[];
  risks: Risk[];
}

class EstimationManager {
  calculateWeightedEstimate(estimation: EstimationPoint): number {
    // PERT formula: (Optimistic + 4*MostLikely + Pessimistic) / 6
    return (estimation.optimistic + 4 * estimation.mostLikely + estimation.pessimistic) / 6;
  }

  calculateConfidence(estimation: EstimationPoint): number {
    // Confidence based on range: smaller range = higher confidence
    const range = estimation.pessimistic - estimation.optimistic;
    const average = (estimation.optimistic + estimation.pessimistic) / 2;
    return Math.max(0, 100 - (range / average) * 100);
  }
}

// Voorbeeld estimation
const userAuthEstimation: EstimationPoint = {
  optimistic: 5,    // dagen
  mostLikely: 8,    // dagen
  pessimistic: 15   // dagen
};

const weightedEstimate = estimationManager.calculateWeightedEstimate(userAuthEstimation);
// Resultaat: 8.33 dagen (veel realistischer dan alleen "8 dagen")

// Risico assessment systeem
interface Risk {
  id: string;
  description: string;
  probability: number;    // 0-100%
  impact: number;        // 0-100%
  category: 'technical' | 'business' | 'external';
  mitigation: string[];
}

interface RiskAssessment {
  risks: Risk[];
  totalRiskScore: number;
  highRiskItems: Risk[];
  mitigationPlan: MitigationPlan;
}

class RiskManager {
  calculateRiskScore(risk: Risk): number {
    return (risk.probability * risk.impact) / 100;
  }

  assessProjectRisks(tasks: TaskEstimation[]): RiskAssessment {
    const risks: Risk[] = [];
    
    // Technische risico's
    risks.push({
      id: 'tech-1',
      description: 'Nieuwe technologie learning curve',
      probability: 70,
      impact: 60,
      category: 'technical',
      mitigation: ['Training', 'Proof of concept', 'Expert consultation']
    });

    // Business risico's
    risks.push({
      id: 'business-1',
      description: 'Scope creep door veranderende requirements',
      probability: 80,
      impact: 70,
      category: 'business',
      mitigation: ['Change control process', 'Regular client communication', 'Buffer in estimation']
    });

    // Externe risico's
    risks.push({
      id: 'external-1',
      description: 'Third-party API dependencies',
      probability: 30,
      impact: 80,
      category: 'external',
      mitigation: ['Backup solutions', 'Service level agreements', 'Monitoring']
    });

    const totalRiskScore = risks.reduce((sum, risk) => sum + this.calculateRiskScore(risk), 0);
    const highRiskItems = risks.filter(risk => this.calculateRiskScore(risk) > 50);

    return {
      risks,
      totalRiskScore,
      highRiskItems,
      mitigationPlan: this.createMitigationPlan(highRiskItems)
    };
  }
}

// Iteratieve estimation refinement
interface EstimationRefinement {
  iteration: number;
  originalEstimate: number;
  refinedEstimate: number;
  confidence: number;
  newInformation: string[];
  adjustments: EstimationAdjustment[];
}

interface EstimationAdjustment {
  reason: string;
  impact: number;        // percentage change
  justification: string;
}

class EstimationRefiner {
  async refineEstimation(
    originalEstimation: TaskEstimation,
    newInformation: string[]
  ): Promise<EstimationRefinement> {
    let refinedEstimate = originalEstimation.estimation;
    const adjustments: EstimationAdjustment[] = [];

    // Analyseer nieuwe informatie
    for (const info of newInformation) {
      if (info.includes('complex')) {
        adjustments.push({
          reason: 'Verhoogde complexiteit gedetecteerd',
          impact: 20,
          justification: 'Nieuwe requirements zijn complexer dan verwacht'
        });
        refinedEstimate.mostLikely *= 1.2;
        refinedEstimate.pessimistic *= 1.3;
      }

      if (info.includes('dependency')) {
        adjustments.push({
          reason: 'Externe dependency risico',
          impact: 15,
          justification: 'Afhankelijkheid van externe service'
        });
        refinedEstimate.pessimistic *= 1.15;
      }

      if (info.includes('proven')) {
        adjustments.push({
          reason: 'Bewezen technologie',
          impact: -10,
          justification: 'Team heeft ervaring met deze technologie'
        });
        refinedEstimate.optimistic *= 0.9;
        refinedEstimate.mostLikely *= 0.95;
      }
    }

    return {
      iteration: 1,
      originalEstimate: this.calculateWeightedEstimate(originalEstimation.estimation),
      refinedEstimate: this.calculateWeightedEstimate(refinedEstimate),
      confidence: this.calculateConfidence(refinedEstimate),
      newInformation,
      adjustments
    };
  }
}

// Probleem: Client verwachtingen
interface ClientExpectation {
  fixedPrice: boolean;
  fixedTimeline: boolean;
  noChanges: boolean;
  guaranteedDelivery: boolean;
}

// Realiteit: Software development
interface DevelopmentReality {
  evolvingRequirements: boolean;
  technicalUncertainty: boolean;
  externalDependencies: boolean;
  learningCurve: boolean;
}

// Client education systeem
interface EducationModule {
  title: string;
  content: string;
  examples: string[];
  interactiveElements: InteractiveElement[];
}

class ClientEducator {
  async educateClient(client: Client): Promise<void> {
    const modules: EducationModule[] = [
      {
        title: 'Waarom Software Estimation Complex Is',
        content: 'Software development is creatief werk met veel onzekerheid...',
        examples: [
          'Netflix: 2 jaar voor streaming, 5 jaar voor recommendation engine',
          'Tesla: Autopilot estimation van 1 jaar werd 3 jaar',
          'SpaceX: Falcon 1 development 2x langer dan geschat'
        ],
        interactiveElements: [
          {
            type: 'estimation_game',
            description: 'Laat client zelf een simpele feature schatten'
          }
        ]
      },
      {
        title: 'Three-Point Estimation Uitleg',
        content: 'We gebruiken drie scenario\'s voor realistische schattingen...',
        examples: [
          'Optimistic: Alles gaat perfect',
          'Most Likely: Normale ontwikkeling',
          'Pessimistic: Alles gaat fout'
        ],
        interactiveElements: [
          {
            type: 'scenario_workshop',
            description: 'Bespreek verschillende scenario\'s samen'
          }
        ]
      },
      {
        title: 'Change Management Proces',
        content: 'Wijzigingen zijn normaal, maar moeten beheerd worden...',
        examples: [
          'Scope change: +20% tijd, +15% budget',
          'Technology change: +30% tijd, +25% budget',
          'Requirement change: +25% tijd, +20% budget'
        ],
        interactiveElements: [
          {
            type: 'change_simulation',
            description: 'Simuleer impact van verschillende wijzigingen'
          }
        ]
      }
    ];

    for (const module of modules) {
      await this.presentModule(client, module);
    }
  }
}

// Probleem: Geen tracking van estimation performance
interface EstimationHistory {
  projectId: string;
  originalEstimate: number;
  actualTime: number;
  accuracy: number;
  lessonsLearned: string[];
}

// Estimation performance tracking
class EstimationTracker {
  private history: EstimationHistory[] = [];

  async trackEstimation(
    projectId: string,
    originalEstimate: number,
    actualTime: number
  ): Promise<void> {
    const accuracy = (originalEstimate / actualTime) * 100;
    
    const history: EstimationHistory = {
      projectId,
      originalEstimate,
      actualTime,
      accuracy,
      lessonsLearned: await this.extractLessonsLearned(projectId)
    };

    this.history.push(history);
    await this.analyzePatterns();
  }

  private async analyzePatterns(): Promise<void> {
    const avgAccuracy = this.history.reduce((sum, h) => sum + h.accuracy, 0) / this.history.length;
    
    console.log(`Gemiddelde estimation accuracy: ${avgAccuracy.toFixed(1)}%`);
    
    if (avgAccuracy < 70) {
      console.log('Estimation accuracy is laag - verbeter estimation proces');
    }
    
    // Identificeer patronen
    const overEstimations = this.history.filter(h => h.accuracy > 120);
    const underEstimations = this.history.filter(h => h.accuracy < 80);
    
    if (overEstimations.length > underEstimations.length) {
      console.log('We schatten te hoog in - verminder conservatisme');
    } else if (underEstimations.length > overEstimations.length) {
      console.log('We schatten te laag in - voeg meer buffer toe');
    }
  }

  generateEstimationReport(): EstimationReport {
    return {
      totalProjects: this.history.length,
      averageAccuracy: this.calculateAverageAccuracy(),
      accuracyTrend: this.calculateAccuracyTrend(),
      recommendations: this.generateRecommendations()
    };
  }
}