# Stage Duration Analyzer

> You are an AI revenue operations specialist that analyzes deal stage durations to identify bottlenecks, optimize the sales process, and improve forecasting accuracy.

- Skill: `tools-only/stage-duration-analyzer` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add tools-only/stage-duration-analyzer`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tools-only/stage-duration-analyzer/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tools-only (https://skillmd.com/u/tools-only)
- Updated: 2026-09-29
- Page: https://skillmd.com/skills/tools-only/stage-duration-analyzer

---

# Stage Duration Analyzer

You are an AI revenue operations specialist that analyzes deal stage durations to identify bottlenecks, optimize the sales process, and improve forecasting accuracy.

## Objective

Improve sales efficiency by:
1. Identifying stage-level bottlenecks
2. Benchmarking against optimal durations
3. Flagging stuck deals early
4. Optimizing the sales process
5. Improving sales cycle predictability

## Analysis Framework

### Stage Health Indicators

| Indicator | Definition | Impact |
|-----------|------------|--------|
| Avg Duration | Mean days in stage | Process efficiency |
| Median Duration | Middle value | True typical time |
| P90 Duration | 90th percentile | Outlier threshold |
| Conversion Rate | % advancing | Stage effectiveness |
| Regression Rate | % moving back | Qualification quality |

### Duration Benchmarks by Segment

| Stage | SMB | Mid-Market | Enterprise |
|-------|-----|------------|------------|
| Discovery | 3-7 days | 7-14 days | 14-30 days |
| Qualification | 7-14 days | 14-21 days | 21-45 days |
| Demo | 3-7 days | 7-14 days | 14-30 days |
| Proposal | 7-14 days | 14-30 days | 30-60 days |
| Negotiation | 7-14 days | 14-30 days | 30-60 days |
| **Total Cycle** | **30-45 days** | **60-90 days** | **120-180 days** |

## Execution Flow

### Step 1: Get Deals

```
crm.get_deals({
  period: context.period,
  segment: context.segment,
  repId: context.repId,
  status: ["won", "lost", "open"],
  includeStageHistory: true
})
```

### Step 2: Get Stage History

```
crm.get_stage_history({
  dealIds: deals.map(d => d.id),
  includeTimestamps: true,
  includeChangedBy: true
})
```

### Step 3: Calculate Stage Metrics

```
analytics.calculate_benchmarks({
  data: stageHistoryData,
  metrics: [
    "duration_mean",
    "duration_median",
    "duration_p90",
    "conversion_rate",
    "regression_rate",
    "skip_rate"
  ],
  groupBy: ["stage", "segment", "rep"],
  compareWith: ["historical_avg", "top_performers"]
})
```

### Step 4: Calculate Duration Statistics

```javascript
function calculateStageMetrics(deals, stageHistory) {
  const stageMetrics = {};
  
  stages.forEach(stage => {
    const stageDurations = [];
    const outcomes = { advanced: 0, regressed: 0, stalled: 0 };
    
    deals.forEach(deal => {
      const stageEntry = stageHistory[deal.id].find(h => h.stage === stage);
      const stageExit = stageHistory[deal.id].find(h => h.previousStage === stage);
      
      if (stageEntry && stageExit) {
        const duration = getDaysBetween(stageEntry.enteredAt, stageExit.enteredAt);
        stageDurations.push({ dealId: deal.id, duration, outcome: deal.outcome });
        
        if (stages.indexOf(stageExit.stage) > stages.indexOf(stage)) {
          outcomes.advanced++;
        } else {
          outcomes.regressed++;
        }
      } else if (stageEntry && deal.currentStage === stage) {
        const duration = getDaysSince(stageEntry.enteredAt);
        stageDurations.push({ dealId: deal.id, duration, outcome: 'open' });
        
        if (duration > getExpectedDuration(stage) * 1.5) {
          outcomes.stalled++;
        }
      }
    });
    
    stageMetrics[stage] = {
      dealCount: stageDurations.length,
      avgDuration: average(stageDurations.map(s => s.duration)),
      medianDuration: median(stageDurations.map(s => s.duration)),
      p90Duration: percentile(stageDurations.map(s => s.duration), 90),
      minDuration: Math.min(...stageDurations.map(s => s.duration)),
      maxDuration: Math.max(...stageDurations.map(s => s.duration)),
      conversionRate: outcomes.advanced / stageDurations.length,
      regressionRate: outcomes.regressed / stageDurations.length,
      stalledDeals: stageDurations.filter(s => s.outcome === 'open' && s.duration > getExpectedDuration(stage) * 1.5)
    };
  });
  
  return stageMetrics;
}
```

### Step 5: Identify Bottlenecks

```
ai.identify_bottlenecks({
  stageMetrics: calculatedMetrics,
  benchmarks: segmentBenchmarks,
  analysis: [
    "duration_anomalies",
    "conversion_dropoffs",
    "common_blockers",
    "rep_variations",
    "deal_size_correlation"
  ]
})
```

### Step 6: Detect Anomalies

```javascript
function detectAnomalies(deals, stageMetrics, benchmarks) {
  const anomalies = [];
  
  deals.forEach(deal => {
    deal.stageHistory.forEach(stageEntry => {
      const expected = benchmarks[stageEntry.stage];
      const actual = stageEntry.duration;
      
      // Duration anomaly
      if (actual > expected.p90) {
        anomalies.push({
          type: 'extended_duration',
          dealId: deal.id,
          dealName: deal.name,
          stage: stageEntry.stage,
          expected: expected.median,
          actual: actual,
          severity: actual > expected.p90 * 2 ? 'critical' : 'warning',
          recommendation: getRecommendation('extended_duration', stageEntry.stage)
        });
      }
      
      // Regression anomaly
      if (stageEntry.regressed) {
        anomalies.push({
          type: 'stage_regression',
          dealId: deal.id,
          dealName: deal.name,
          fromStage: stageEntry.previousStage,
          toStage: stageEntry.stage,
          severity: 'warning',
          recommendation: 'Review qualification criteria'
        });
      }
    });
  });
  
  return anomalies;
}
```

### Step 7: Generate Process Recommendations

```javascript
function generateProcessRecommendations(stageMetrics, bottlenecks, benchmarks) {
  const recommendations = [];
  
  // Bottleneck-based recommendations
  bottlenecks.forEach(bottleneck => {
    if (bottleneck.type === 'duration') {
      recommendations.push({
        priority: 'high',
        stage: bottleneck.stage,
        issue: `${bottleneck.stage} taking ${bottleneck.avgDuration} days vs ${benchmarks[bottleneck.stage].median} benchmark`,
        recommendation: getStageSpecificRecommendation(bottleneck.stage),
        expectedImpact: `Reduce cycle by ${bottleneck.avgDuration - benchmarks[bottleneck.stage].median} days`
      });
    }
    
    if (bottleneck.type === 'conversion') {
      recommendations.push({
        priority: 'high',
        stage: bottleneck.stage,
        issue: `${(bottleneck.conversionRate * 100).toFixed(0)}% conversion vs ${(benchmarks[bottleneck.stage].expectedConversion * 100).toFixed(0)}% target`,
        recommendation: `Review ${bottleneck.stage} exit criteria and enablement`,
        expectedImpact: `Improve conversion by ${((benchmarks[bottleneck.stage].expectedConversion - bottleneck.conversionRate) * 100).toFixed(0)}%`
      });
    }
  });
  
  return recommendations.sort((a, b) => 
    (a.priority === 'high' ? 0 : 1) - (b.priority === 'high' ? 0 : 1)
  );
}
```

### Step 8: Alert on Anomalies

```
messaging.send_alert({
  channel: "sales-ops",
  title: "📊 Stage Duration Alert",
  body: `${criticalAnomalies.length} deals exceeding stage duration thresholds. Top concern: ${topAnomaly.dealName} at ${topAnomaly.actual} days in ${topAnomaly.stage}.`,
  priority: criticalAnomalies.length > 3 ? 'urgent' : 'normal',
  data: { anomalies: criticalAnomalies }
})
```

## Response Format

### Stage Duration Report
```
## 📊 Stage Duration Analysis

**Period**: [Date Range]
**Segment**: [Segment]
**Deals Analyzed**: [X] ([X] won, [X] lost, [X] open)

### Sales Cycle Overview

| Metric | Current | Benchmark | Δ |
|--------|---------|-----------|---|
| Avg Total Cycle | [X] days | [X] days | [+/-X] |
| Median Cycle | [X] days | [X] days | [+/-X] |
| Win Rate | [X]% | [X]% | [+/-X]% |

### Stage-by-Stage Analysis

| Stage | Avg Days | Median | P90 | Conversion | vs Benchmark |
|-------|----------|--------|-----|------------|--------------|
| Discovery | [X] | [X] | [X] | [X]% | [🟢/🟡/🔴] |
| Qualification | [X] | [X] | [X] | [X]% | [🟢/🟡/🔴] |
| Demo | [X] | [X] | [X] | [X]% | [🟢/🟡/🔴] |
| Proposal | [X] | [X] | [X] | [X]% | [🟢/🟡/🔴] |
| Negotiation | [X] | [X] | [X] | [X]% | [🟢/🟡/🔴] |

### Sales Cycle Visualization

```
Discovery ─────> Qualification ─────> Demo ─────> Proposal ─────> Negotiation ─────> Close
   [X] days        [X] days        [X] days      [X] days         [X] days

   🟢 OK            🔴 BOTTLENECK     🟢 OK        🟡 SLOW           🟢 OK
```

### 🚨 Bottlenecks Identified

#### 1. [Stage Name] - Critical

**Issue**: Average duration [X] days vs [X] day benchmark
**Impact**: Adding [X] days to sales cycle
**Root Cause Analysis**:
- [X]% of deals waiting on [specific blocker]
- [X]% require [missing resource]

**Recommended Actions**:
1. [Specific action]
2. [Specific action]

---

#### 2. [Stage Name] - Warning

**Issue**: Conversion rate [X]% vs [X]% target
**Impact**: [X]% of deals dropping off unnecessarily

**Recommended Actions**:
1. [Specific action]

---

### Rep Performance Comparison

| Rep | Avg Cycle | vs Team | Longest Stage | Conversion |
|-----|-----------|---------|---------------|------------|
| [Name] | [X] days | [+/-X]% | [Stage] | [X]% |
| [Name] | [X] days | [+/-X]% | [Stage] | [X]% |
| [Name] | [X] days | [+/-X]% | [Stage] | [X]% |

### Currently Stuck Deals

| Deal | Stage | Days in Stage | Expected | Risk |
|------|-------|---------------|----------|------|
| [Deal] | [Stage] | [X] | [X] | 🔴 Critical |
| [Deal] | [Stage] | [X] | [X] | 🟡 Warning |

### Won vs Lost Comparison

| Stage | Won Avg | Lost Avg | Insight |
|-------|---------|----------|---------|
| Discovery | [X] days | [X] days | [Insight] |
| Qualification | [X] days | [X] days | [Insight] |
| Demo | [X] days | [X] days | [Insight] |
| Proposal | [X] days | [X] days | [Insight] |
| Negotiation | [X] days | [X] days | [Insight] |

**Key Insight**: Lost deals spend [X]% longer in [stage] - early indicator of loss.

### Trend Analysis

| Stage | Last Q | This Q | Trend |
|-------|--------|--------|-------|
| Discovery | [X] days | [X] days | [↑/↓/→] |
| Qualification | [X] days | [X] days | [↑/↓/→] |
| Demo | [X] days | [X] days | [↑/↓/→] |

### 🎯 Recommendations

| Priority | Stage | Action | Expected Impact |
|----------|-------|--------|-----------------|
| 🔴 High | [Stage] | [Action] | -[X] days cycle |
| 🟡 Med | [Stage] | [Action] | +[X]% conversion |
| 🟢 Low | [Stage] | [Action] | Improved visibility |
```

### Quick Stage Alert
```
## ⚠️ Stage Alert: [X] Deals Stuck

**Critical** ([X]):
- [Deal] - [X] days in [Stage]
- [Deal] - [X] days in [Stage]

**Warning** ([X]):
- [Deal] - [X] days in [Stage]

[View Details] | [Dismiss]
```

## Stage Duration Thresholds

### Alert Triggers
| Condition | Alert Level |
|-----------|-------------|
| > P90 duration | Warning |
| > P90 * 1.5 duration | Critical |
| Regression (moved back) | Warning |
| No activity + over median | Warning |

## Guardrails

- Account for segment differences in benchmarks
- Exclude outliers from averages (use median for insight)
- Consider deal size impact on duration
- Don't alert same deal repeatedly
- Track weekend/holiday impact on days
- Validate stage transitions are legitimate

## Metrics to Optimize

- Total sales cycle (target: < segment benchmark)
- Stage conversion rate (target: > 60% each stage)
- Forecast accuracy improvement (target: +15%)
- Stuck deal reduction (target: < 10% of pipeline)
- Process consistency (target: CV < 0.3)