How Airbnb’s Impulse Framework Enables Scalable, Decentralized Load Testing

Architecture

System‑level load testing is essential for reliability and efficiency. Impulse is Airbnb’s internal load‑testing‑as‑a‑service framework that generates synthetic load, simulates dependencies, and collects production traffic, all integrated with the observability stack and CI processes.

Core Components

Load Generator – Dynamically creates context‑aware requests using synthetic or recorded traffic to test various scenarios.

Dependency Simulator – Mocks downstream responses and latency, allowing load tests without real third‑party services and enabling regression testing without affecting downstream systems.

Traffic Collector – Captures upstream and downstream traffic from production and replays it in test environments.

Test API Generator – Wraps asynchronous workflows as HTTP APIs so they can be load‑tested like synchronous calls.

Load Generator Details

The generator is containerized and decentralized; each test run spawns a fresh set of containers, providing isolation, scalability, and cost efficiency. It supports context‑aware testing where requests depend on prior responses, and developers write test logic in Java or Kotlin for maximum flexibility.

class HelloWorldLoadGenerator : LoadGenerator {
    override suspend fun run() {
        val createdEntity = sutApiClient.create(CreateRequest(name="foo", ...)).data
        // request with id from previous response (context)
        val updateResponse = sutApiClient.update(UpdateRequest(id=createdEntity.id, name="bar"))
        // ... other operations
        // clean up
        sutApiClient.delete(DeleteRequest(id=createdEntity.id))
    }
}

Decentralization Benefits

Isolation: tests for different services do not interfere with each other.

Scalability: container count can be adjusted based on traffic demand.

Cost‑effectiveness: containers exist only for the duration of a test run.

Impulse distributes workers evenly across data centers, ensuring realistic traffic distribution and allowing total TPS to be controlled via configuration.

Dependency Simulator Details

Each service runs its own simulator, eliminating cross‑service interference. Simulators can mock HTTP JSON, Airbnb Thrift, and Airbnb GraphQL endpoints, and support both synthetic responses (written in Java/Kotlin) and replayed responses collected from production.

downstreamsMocking.every(
    thriftRequest<FooRequest>().having { it.message == "hello" }
).returns { request ->
    ThriftDownstream.Response.thriftEncoded(
        HttpStatus.OK,
        FooResponse.builder.reply("${request.message} world").build()
    )
}.with {
    delay = latencyFromP95(p95=500.miliseconds, min=200.miliseconds, max=2000.miliseconds)
}

Traffic Collector

The collector records upstream and downstream traffic and their relationships, enabling high‑fidelity replay of production traffic during load tests, so test‑environment services behave identically to production.

Test API Generator

It creates HTTP APIs that wrap asynchronous event‑driven workflows (e.g., MQ events) so they can be exercised by load generators, allowing realistic performance testing of async logic without involving the message broker.

Integration with Other Test Frameworks

Impulse’s modular design integrates with Airbnb’s broader testing ecosystem, covering development, pre‑release, and production environments, and fits into CI/CD pipelines for systematic service testing.

Conclusion

Impulse enables self‑service, decentralized load testing at Airbnb, has been adopted by multiple backend services, and continues to receive positive feedback for identifying performance bottlenecks, thread‑pool pressure, and memory usage issues.