Shielding the Core: Architecting Resilience with Multi-Layer Defenses

Anderson Parra discusses strategies to handle sudden traffic spikes in systems such as SeatGeek, which can overwhelm even well-designed infrastructure.

• Context: High-demand ticket onsales can lead to extreme pressure on backend services, demanding resilient architecture.
• Challenge: Traditional methods like autoscaling take time, risking system collapse under heavy load.

Architectural Approach:

• Layered shielding architecture distributes responsibilities to manage traffic effectively.
• Edge Mechanisms: Caching, shielding, and admission control mechanisms absorb traffic bursts.
• API Gateways: Enforces fairness through rate limiting and validation.
• Kubernetes Policies: Control networking to protect service boundaries and manage failures.

Principles for Resilience:

1. Observe Early: Systems should react to pressure signals, not just failures.
2. Control Failures: Use rate limits and queues to manage entry and load.
3. Protect the Core: Prioritize critical services to ensure core system survival.
4. Continuous Adaptation: Systems must adapt through observability and feedback signals.

Implementation Strategies:

• Utilize signal-based control mechanisms to adjust rate limits and identify abusive actors.
• Use a feedback loop to dynamically adapt system behavior based on observed pressures.

Concluding Remarks: Traffic spikes are inevitable, but collapse is a design choice. Resilient systems should focus on early signals and controlled failures to maintain stability under load.

This is the end of the AI-generated content.

High-demand events can cause sudden traffic spikes that overwhelm even well-designed systems. In ticketing platforms, millions of users — alongside increasingly sophisticated automated agents — may arrive simultaneously, placing extreme pressure on backend services.

At SeatGeek, we observed that even elastic infrastructure has limits: autoscaling takes time to react, and systems must survive while capacity catches up. To address this gap, we designed a layered shielding architecture that distributes defensive responsibilities across multiple parts of the platform.

At the edge, caching, shielding, and admission control mechanisms such as queueing absorb traffic bursts before they reach the origin. API gateways enforce fairness through rate limiting and request validation. Deeper in the stack, Kubernetes-native networking policies and platform controls help contain failures and protect service boundaries.

This layered approach allows the system to shed load early, protect critical services, and degrade gracefully during extreme demand. But resilience is not static: traffic patterns evolve, new bottlenecks emerge, and systems must continuously adapt through observability and feedback signals.

In this talk, we will explore the architecture and operational lessons behind building multi-layer shields that protect core systems under internet-scale traffic, and share practical insights for designing resilient platforms that can withstand traffic stampedes without bringing down the entire ecosystem.