💻 computer science

A Genetic Algorithm-Based Approach for Cascading Failure Analysis in Serverless Architectures

This paper proposes a Genetic Algorithm-based framework that integrates chaos and resilience engineering to systematically analyze cascading failures in serverless architectures, identifying worst-case fault scenarios and quantifying resilience boundaries to evaluate the effectiveness of cold start mitigation strategies.

Original authors: Vansh Arora, Sumeet Mangat, Neenu Garg

Published 2026-07-31

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Vansh Arora, Sumeet Mangat, Neenu Garg

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the internet as a massive, bustling city where millions of tiny, invisible workers (called "functions") spring into action the moment you click a button. These workers don't live in big, permanent offices; instead, they pop into existence only when needed, do their job, and then vanish. This is the world of Serverless Computing. It's incredibly efficient because you only pay for the time these workers are actually busy. However, there's a catch: if a worker hasn't been called in a while, they have to wake up from a deep sleep, put on their tools, and get ready before they can help. This "waking up" time is called a Cold Start, and it can cause a slow, frustrating delay.

Now, imagine if one slow worker causes the next worker to wait, which makes the third worker panic, and suddenly the whole line of workers grinds to a halt. This is a Cascading Failure, where a small problem snowballs into a system-wide meltdown. To stop this, engineers usually try to guess when the workers will be busy and keep some of them awake (a strategy called "pre-warming"). But the real world is messy and unpredictable; what works on a quiet Tuesday might fail spectacularly during a flash sale. This is where Chaos Engineering comes in: the practice of intentionally breaking things on purpose to see how the system reacts. But breaking things randomly is like throwing darts in the dark; you might hit a weak spot, or you might miss the real danger entirely.

This is the puzzle tackled by Vansh Arora, Sumeet Mangat, and Neenu Garg in their research. They asked: How can we find the absolute worst-case scenario for these serverless systems without just guessing? Their answer is a clever mix of chaos engineering and Genetic Algorithms—a type of computer program inspired by how nature evolves. Instead of randomly throwing darts, their system acts like a digital naturalist. It creates thousands of different "what-if" scenarios (like "what if the first worker is 5 seconds late?" or "what if the second worker fails 10% of the time?"), tests them, and then "breeds" the most dangerous combinations together. Over time, the system evolves to identify the specific ranges of delays and failure rates that cause the biggest, most catastrophic crashes, rather than settling on just one single recipe.

The researchers built a digital playground on Amazon Web Services (AWS) to test this. They set up a chain of functions where one triggers the next, mimicking a real-world app. They then let their "evolutionary" program loose. Instead of just hoping to find a problem, the Genetic Algorithm actively hunted for the worst possible conditions. It discovered that by tweaking specific delays and failure rates, it could trigger a chain reaction where the system's response time skyrocketed from a quick 120 milliseconds to a sluggish 920 milliseconds, and the error rate jumped from a tiny 0.5% to a chaotic 12.8%.

The study suggests that this automated, evolutionary approach is far better at finding hidden weaknesses than traditional random testing. In their experiments, the Genetic Algorithm found failure scenarios that caused a queue backlog (a line of waiting requests) to grow to 65 seconds, compared to just 18 seconds with random testing. The team also introduced a way to measure a "Resilience Boundary"—essentially, the exact point where the system stops being able to handle the load and starts to collapse. They found that while some strategies like "Provisioned Concurrency" (keeping workers permanently awake) helped, the most effective method in their tests was "Snapshot-Based Execution," which allowed the system to handle up to 7,000 requests per second before failing, compared to only 3,000 for a system with no special protections.

Ultimately, the paper suggests that we can't just hope our serverless apps are strong; we need to actively evolve our tests to find the breaking points. By using a computer to "breed" the worst possible failures, developers can see exactly where their system is fragile and fix it before real users ever notice. It's a bit like a video game boss that learns your moves and gets harder every time you beat it, ensuring that when the real traffic hits, your system is ready for the toughest fight possible.

Technical Summary: A Genetic Algorithm-Based Approach for Cascading Failure Analysis in Serverless Architectures

Problem Statement
Serverless computing offers scalable, on-demand execution but faces significant challenges regarding "cold start" latency, where function initialization delays occur after periods of inactivity. Under bursty workloads, these delays can propagate across loosely coupled, event-driven functions, leading to cascading failures, queue build-ups, and system instability. Traditional resilience and chaos engineering techniques, often designed for virtual machines or containers, struggle to systematically explore the vast, non-linear search space of failure permutations in serverless environments. Existing mitigation strategies (e.g., pre-warming, provisioned concurrency) rely on heuristic assumptions and lack a systematic method to evaluate their effectiveness against worst-case, automatically discovered failure scenarios. Consequently, the operational limits and resilience boundaries of serverless systems remain poorly understood.

Methodology
The authors propose a "Failure-as-a-Service" framework that integrates Chaos Engineering principles with Genetic Algorithms (GA) to autonomously discover high-impact failure patterns. The system is implemented on AWS Lambda using a multi-stage pipeline: API Gateway $\rightarrow$ Ingestion $\rightarrow$ SQS Queue $\rightarrow$ Fan-out Functions $\rightarrow$ Aggregation Functions.

Problem Formulation: The search for worst-case scenarios is framed as an optimization problem. Fault configurations are encoded as chromosomes consisting of four decision variables: execution delays ( $d_1, d_2$ ) and failure probabilities ( $p_1, p_2$ ) applied to the fan-out and aggregation stages.
Genetic Algorithm Evolution: The GA iteratively evolves a population of fault configurations. It uses selection, crossover, and mutation to maximize a fitness function. This function is a weighted sum of five normalized operational metrics:
- API Gateway error rate.
- Fan-out Lambda throttling.
- Fan-out execution latency (p95).
- Aggregation Lambda throttling.
- SQS queue backlog persistence.
  The objective is to maximize system degradation (fitness), thereby identifying configurations that trigger severe cascading effects.
Resilience Boundary Analysis: To quantify system limits, the authors introduce a Resilience Boundary ( $B_r$ ), defined as the minimum workload intensity at which the system transitions from a resilient state to an unstable state (where the fitness score exceeds a threshold $\tau = 0.7$ ).
Resilience Gain ( $R_g$ ): A metric is defined to quantify the percentage increase in workload capacity achieved by mitigation strategies (Pre-warming, Provisioned Concurrency, Snapshot-Based Execution) compared to a baseline, under the worst-case fault conditions discovered by the GA.

Key Contributions
The paper outlines five primary contributions:

Failure-as-a-Service Framework: A system enabling controlled, synchronized fault injection across interdependent serverless function pipelines using a central configuration repository (DynamoDB).
GA-Based Optimization: Formulating cascading failure discovery as an optimization problem where a Genetic Algorithm autonomously evolves fault parameters to maximize system degradation, moving beyond manual or stochastic testing.
Resilience Boundary Quantification: Introducing a metric to define the specific workload threshold where a serverless system becomes unstable, allowing for the quantitative evaluation of mitigation strategies under identical worst-case conditions.
Empirical Validation: Demonstrating the framework on an AWS Lambda microservice system to reveal architectural risks such as retry storms and resource exhaustion.
Efficiency Comparison: Showing through experiments that GA-guided fault injection identifies worst-case scenarios faster and more effectively than traditional random chaos testing protocols.

Experimental Results
The framework was evaluated on AWS Lambda using Python 3.11 under four workload intensities (200 to 10,000 requests). Key findings include:

Superior Failure Discovery: The GA-based approach significantly outperformed baseline (no injection) and random fault injection methods. Under GA-guided faults, latency reached 920 ms (vs. 350 ms for random), error rates rose to 12.8% (vs. 4.2%), and queue backlog increased to 65 seconds (vs. 18 seconds).
Scalability and Tail Latency: As workload increased to 10,000 requests, GA-induced latency reached 8,200 ms, compared to 1,400 ms for the baseline. Tail latency analysis showed p99 values of 4,100 ms for GA-based configurations, indicating substantial amplification of worst-case delays.
Mitigation Effectiveness: When applying the GA-discovered worst-case faults to different mitigation strategies, Snapshot-Based Execution (SnapStart) demonstrated the highest resilience, achieving a resilience boundary of 7,000 requests/s, followed by Provisioned Concurrency (6,500), Pre-warming (4,500), and No Mitigation (3,000).
Ablation Study: Removing GA components (mutation, crossover, or specific metrics) resulted in lower fitness scores, confirming the necessity of the full evolutionary framework for effective failure discovery.

Significance and Claims
The authors claim that this research provides a systematic, automated approach to uncovering hidden vulnerabilities in serverless architectures that are difficult to detect via manual testing. By shifting the focus from merely reducing cold-start latency to actively searching for the conditions that cause system collapse, the framework offers a deeper understanding of serverless resilience. The introduction of the Resilience Boundary and Resilience Gain metrics allows for quantitative comparisons of mitigation strategies, demonstrating that techniques like SnapStart and Provisioned Concurrency not only reduce latency but also significantly extend the workload range over which stable operation can be maintained. The work suggests that evolutionary search is a viable and necessary tool for stress-testing complex, black-box distributed systems.

Technical Summary: A Genetic Algorithm-Based Approach for Cascading Failure Analysis in Serverless Architectures

More like this