Shadow Mode for Dangerous Refactors

In this lesson, you will learn how to safely test high-risk refactors by running new, experimental code alongside your stable production logic without letting the user see the difference.

The Problem: When "Try-Catch" Isn't Enough

Sometimes, you need to replace a complex, legacy calculation engine or a database query optimizer. Even with perfect unit tests, the "real-world" data in production often contains edge cases that cause crashes or logical discrepancies. Running the new code directly is a high-stakes gamble.

The Solution: Shadow Execution

"Shadow Mode" (or "Dark Launching") allows you to execute both the stable code and the experimental code in the same request cycle. You return the result of the stable version to the user, but you process the experimental version in the background, comparing the results to detect potential bugs.

Consider this implementation pattern:

async function handleOrderCalculation(orderData) {
  // 1. Run stable, trusted logic
  const stableResult = await calculateLegacy(orderData);

  // 2. Run experimental logic in a non-blocking "shadow"
  // We use a separate path so it doesn't delay the response
  runShadowComparison(orderData, stableResult);

  // 3. User only sees the trusted result
  return stableResult;
}

async function runShadowComparison(data, expected) {
  try {
    const experimentalResult = await calculateNewEngine(data);
    
    if (experimentalResult !== expected) {
      logDiscrepancy({ expected, experimentalResult, data });
    }
  } catch (err) {
    // Log the error silently; the user is unaffected
    logShadowError(err);
  }
}

Why this is a "Resilient System" Pattern

By isolating the shadow execution from the main control flow, you ensure that even if the new code throws an unhandled exception or enters an infinite loop, your production request remains untouched. It transforms a "dangerous refactor" into a "passive observation." Once your logs show zero discrepancies between the legacy output and the new output over a period of time, you can confidently flip the switch to make the experimental code the new primary source of truth.

Key Takeaway: Shadow Mode allows you to validate new, unpredictable logic against live production traffic by treating the new code as a secondary, non-blocking observer that cannot impact the end user.