Graceful Degradation

Sometimes chains can't complete fully, but partial results are still valuable. Graceful degradation ensures your system provides value even when things go wrong.

The Degradation Spectrum

Not all failures are equal. Think of degradation as a spectrum:

Full Success ◄──────────────────────────────────► Complete Failure
     │                                                   │
     │  Partial Results  │  Degraded Output  │  Fallback │
     └────────────────────────────────────────────────────┘

Level	Description	Example
Full Success	All steps complete, high quality	Full analysis with all sections
Partial Results	Some steps complete, useful output	Analysis missing one section
Degraded Output	Lower quality but functional	Summary instead of full analysis
Fallback	Minimal but safe response	Template response + escalation
Complete Failure	Nothing useful produced	Error message only

Designing for Degradation

Identify Critical vs Optional Steps

Map your chain to identify what's essential:

const chainSteps = [
  { name: 'validateInput', critical: true },      // Must succeed
  { name: 'extractEntities', critical: true },   // Must succeed
  { name: 'enrichWithMetadata', critical: false }, // Nice to have
  { name: 'calculateSentiment', critical: true }, // Must succeed
  { name: 'generateInsights', critical: false },  // Nice to have
  { name: 'formatOutput', critical: true }        // Must succeed
];

Plan Degradation Paths

Partial Results Pattern

When some steps succeed and others fail, combine available results:

async function runChainWithPartialResults(input) {
  const results = {
    extraction: null,
    enrichment: null,
    analysis: null,
    generation: null
  };
  const errors = [];

  // Step 1: Extraction (critical)
  try {
    results.extraction = await extractStep(input);
  } catch (error) {
    // Can't continue without extraction
    return { success: false, error: 'Extraction failed', partial: null };
  }

  // Step 2: Enrichment (optional)
  try {
    results.enrichment = await enrichStep(results.extraction);
  } catch (error) {
    errors.push({ step: 'enrichment', error: error.message });
    results.enrichment = { skipped: true, reason: error.message };
  }

  // Step 3: Analysis (critical)
  try {
    results.analysis = await analyzeStep(results.extraction, results.enrichment);
  } catch (error) {
    // Try without enrichment
    try {
      results.analysis = await analyzeStep(results.extraction, null);
      errors.push({ step: 'analysis', warning: 'Completed without enrichment' });
    } catch (retryError) {
      return { success: false, error: 'Analysis failed', partial: results };
    }
  }

  // Continue with remaining steps...

  return {
    success: true,
    results,
    warnings: errors,
    completeness: calculateCompleteness(results)
  };
}

Quality Tiers

Define different output quality levels:

Tier 1: Premium (All Steps Succeed)

{
  "tier": "premium",
  "analysis": {
    "sentiment": "positive",
    "confidence": 0.92,
    "themes": ["quality", "value", "service"],
    "detailed_breakdown": {...},
    "competitive_context": {...},
    "recommendations": [...],
    "supporting_quotes": [...]
  }
}

Tier 2: Standard (Optional Steps Skipped)

{
  "tier": "standard",
  "analysis": {
    "sentiment": "positive",
    "confidence": 0.92,
    "themes": ["quality", "value", "service"],
    "recommendations": [...],
    "note": "Detailed breakdown unavailable"
  }
}

Tier 3: Basic (Minimal Viable Output)

{
  "tier": "basic",
  "analysis": {
    "sentiment": "positive",
    "note": "Limited analysis available due to processing issues"
  }
}

Implementing Graceful Degradation

Step-Level Degradation

Chain-Level Degradation

async function degradableChain(input) {
  const config = {
    tiers: [
      {
        name: 'premium',
        steps: ['extract', 'enrich', 'analyze', 'enhance', 'format']
      },
      {
        name: 'standard',
        steps: ['extract', 'analyze', 'format']
      },
      {
        name: 'basic',
        steps: ['extract', 'simpleFormat']
      }
    ]
  };

  for (const tier of config.tiers) {
    try {
      const result = await runSteps(tier.steps, input);
      return { tier: tier.name, result };
    } catch (error) {
      console.log(`${tier.name} failed, trying next tier...`);
    }
  }

  return {
    tier: 'fallback',
    result: generateFallbackResponse(input)
  };
}

Communicating Degradation

To Downstream Steps

{
  "data": {...},
  "metadata": {
    "degradationLevel": "standard",
    "skippedSteps": ["enrichment"],
    "confidenceImpact": "reduced",
    "notes": [
      "Metadata enrichment was unavailable",
      "Analysis based on core data only"
    ]
  }
}

To End Users

Monitoring Degradation

Track degradation to identify systemic issues:

const degradationMetrics = {
  // Count by tier
  tierCounts: {
    premium: 8500,
    standard: 1200,
    basic: 250,
    fallback: 50
  },

  // Reasons for degradation
  degradationReasons: {
    'enrichment_timeout': 800,
    'analysis_rate_limit': 400,
    'generation_failure': 200,
    'unknown': 50
  },

  // Trend over time
  degradationRate: '15%', // Last 24 hours

  // Alert threshold
  alertThreshold: '20%'
};

Exercise: Design Degradation Strategy

Design a complete degradation strategy for this scenario:

Key Takeaways

• Graceful degradation ensures value even when things fail
• Identify critical vs optional steps in your chain
• Define quality tiers before implementation
• Implement partial results to maximize value from successful steps
• Communicate degradation clearly to downstream consumers
• Monitor degradation rates to catch systemic issues
• Design fallbacks that meet minimum viable requirements

In the next module, we'll explore branching and conditional logic in chains.