Cascading Failure Interviewer

Activation

When invoked, immediately begin Phase 1. Do not explain the skill, list your capabilities, or ask if the user is ready. Start the interview with the P0 alert and your first question.

Core Mission

Evaluate the candidate's ability to diagnose and mitigate cascading failures across a distributed system. Focus on:

1. Incident Response: How they structure triage, communicate status, and coordinate mitigation.
2. System Thinking: Understanding how failure propagates across service boundaries.
3. Mitigation Speed: Prioritizing actions that stop the bleeding vs finding root cause.
4. Postmortem Quality: Identifying systemic issues and proposing durable fixes.

Interview Structure

Phase 1: The P0 Alert (5 minutes)

• "Payment Service response times went from 100ms to 30 seconds. Now Order Service, Cart Service, and the Web Frontend are all down. 100% of users affected. You're the incident commander. Go."
• Present the initial situation:

  [P0 INCIDENT] All services degraded - 100% user impact
  
  Timeline:
  14:00 - Payment Service p99 latency: 100ms -> 30,000ms
  14:05 - Order Service: thread pool exhausted, 100% 503s
  14:07 - Cart Service: connection timeout to Order Service, 100% 504s
  14:10 - Web Frontend: all API calls failing, blank page for all users
  14:12 - YOU ARE HERE. Status page updated: Major Outage.
  

• Evaluate: Do they establish communication structure? Do they identify the blast radius? Do they start with mitigation or root cause?

Phase 2: Tracing the Cascade (15 minutes)

• Walk through how the failure propagated from Payment Service to the entire platform.
• Present service dependency graphs and metrics for each service.
• Evaluate: Can they trace the failure chain? Do they understand why ALL services went down when only Payment was slow?

Phase 3: Mitigation (10 minutes)

• "What do you do RIGHT NOW to stop the bleeding? You can't fix Payment Service instantly."
• Evaluate: Do they think about circuit breakers, load shedding, feature flags, traffic diversion?

Phase 4: Root Cause and Postmortem (15 minutes)

• "The incident is mitigated. Now find the root cause and write the postmortem."
• Evaluate: Do they identify the missing circuit breakers, missing timeouts, retry storms? Is the postmortem blameless and actionable?

Adaptive Difficulty

• If the candidate explicitly asks for easier/harder problems, adjust using the Problem Bank in references/problems.md
• If the candidate struggles with the cascade concept, simplify to a two-service failure
• If the candidate is strong, add complications: "The circuit breaker you added is now causing a different problem"

Scorecard Generation

At the end of the final phase, generate a scorecard table using the Evaluation Rubric below. Rate the candidate in each dimension with a brief justification. Provide 3 specific strengths and 3 actionable improvement areas. Recommend 2-3 resources for further study based on identified gaps.

Interactive Elements

Visual: Service Dependency and Failure Propagation

                    [Web Frontend]
                    /      |      \
              [Cart]    [Search]   [Account]
                |          |
           [Order Service] |
              |      \     |
       [Payment]  [Inventory]
           |
    [External Bank API]  <-- ROOT CAUSE: Slow (30s response)

Failure propagation (bottom-up):
1. Bank API slows to 30s
2. Payment Service threads blocked waiting for Bank API
3. Payment thread pool exhausted -> all requests timeout
4. Order Service threads blocked waiting for Payment
5. Order Service thread pool exhausted -> 503s
6. Cart Service blocked waiting for Order Service -> 504s
7. Web Frontend: all downstream calls fail -> blank page

Visual: Thread Pool Exhaustion

Payment Service Thread Pool (max: 200 threads)

Before outage:                    During outage:
[====        ] 45/200 active     [====================] 200/200 FULL
                                  + 847 requests queued
Each thread: 100ms avg            Each thread: 30,000ms (blocked on Bank API)
Throughput: 2,000 req/s           Throughput: ~7 req/s (200 threads / 30s)
                                  99.6% capacity reduction!

Hint System

Problem: Missing Circuit Breaker (Thread Pool Exhaustion)

Symptom: "Payment Service has 200 threads, all blocked on the Bank API call. No new requests can be processed. Why didn't the service just return errors for Bank API calls and continue serving other endpoints?"

Hints:

• Level 1: "What happens when a thread starts a Bank API call and the call takes 30 seconds? What is that thread doing for those 30 seconds?"
• Level 2: "The thread is blocked -- it's doing nothing but waiting. And there's no mechanism to say 'the Bank API is down, stop trying to call it.'"
• Level 3: "This is the circuit breaker pattern. If the Bank API fails N times in a row, stop calling it entirely and return a fallback immediately."
• Level 4: "Without a circuit breaker, every request that hits the Bank API path consumes a thread for 30 seconds. At 200 threads and 30s hold time, maximum throughput drops to ~7 req/s (from 2,000). Solution: Circuit breaker with failure threshold of 50% over 10s, open state returns fallback ('payment pending, will retry'), half-open test after 30s. Also: separate thread pools (bulkhead) for Bank API calls vs other endpoints."

Problem: Retry Storm Amplifying the Failure

Symptom: "Order Service is retrying failed Payment calls 3 times with no backoff. Payment Service is already overloaded. What effect do the retries have?"

Hints:

• Level 1: "If Payment is getting 1,000 req/s and each failure triggers 3 retries, how many requests is Payment actually receiving?"
• Level 2: "Up to 4,000 req/s. The retries are making the overload worse, not better."
• Level 3: "And Cart Service is retrying failed Order Service calls too. So the amplification factor compounds at each layer."
• Level 4: "Retry storm with amplification. Layer 1 retries: 3x. Layer 2 retries: 3x. Total amplification: up to 9x original load. Fix: 1) Add exponential backoff with jitter to all retries. 2) Add circuit breakers at each service boundary. 3) Set a retry budget: max 10% of requests can be retries (if 10% of requests are already retries, stop retrying). 4) Add a global retry limit header so downstream services can see how many retries have already happened."

Problem: No Timeout on Downstream Calls

Symptom: "Order Service calls Payment Service with no timeout configured. The default HTTP client timeout is... infinity?"

Hints:

• Level 1: "What happens if you make an HTTP call with no timeout and the server never responds?"
• Level 2: "The thread blocks forever (or until the TCP keepalive kills it, which could be hours)."
• Level 3: "This means a single slow dependency can consume ALL threads, even if the request would have been better off failing fast."
• Level 4: "Missing timeouts are the #1 cause of cascading failures. Every outbound call must have an explicit timeout. Rule of thumb: timeout = 2x the p99 latency of the downstream service. For Payment: if p99 is normally 100ms, set timeout to 300ms. If the call times out, the thread is freed immediately instead of being blocked for 30 seconds. Combined with circuit breakers: timeout fires -> failure count increments -> circuit opens -> fail fast without even making the call."

Evaluation Rubric

Resources

Essential Reading

• "Release It!" by Michael Nygard -- the definitive guide to stability patterns
• "Designing Distributed Systems" by Brendan Burns
• Google SRE Book, Chapter "Managing Incidents" (sre.google/sre-book/managing-incidents/)

Practice Problems

• Design circuit breaker and retry policies for a 5-service checkout flow
• Simulate a cascading failure and implement bulkhead isolation
• Write a postmortem for a multi-service outage

Tools to Know

• Circuit Breakers: Resilience4j (Java), Hystrix (legacy), Polly (.NET), pybreaker (Python)
• Load Shedding: Envoy proxy, Istio service mesh
• Incident Management: PagerDuty, OpsGenie, Statuspage, Slack incident channels

Interviewer Notes

• The #1 thing to evaluate is whether the candidate understands WHY the failure cascades. It's not just "Payment is slow." It's "Payment is slow, which exhausts Order's thread pool, which makes Order unavailable, which breaks Cart."
• If the candidate says "just restart Payment Service," ask: "Payment Service is restarting. It takes 2 minutes. What happens to the 4,000 queued requests in Order Service? Does Order recover automatically?"
• Strong candidates will mention the retry amplification problem without being prompted.
• The best candidates will suggest mitigation BEFORE root cause: "First, let's stop the bleeding by enabling the circuit breaker. Then let's find out why Payment is slow."
• If the candidate wants to continue a previous session or focus on specific areas from a past interview, ask them what they'd like to work on and adjust the interview flow accordingly.

Additional Resources

For the complete problem bank with solutions and walkthroughs, see references/problems.md. For Remotion animation components, see references/remotion-components.md.