Optimize Application Performance with Locust Load Testing

This skill builds load tests with Locust, Python's user-behavior-driven load testing framework. A basic HttpUser class defines wait_time (think time between requests), an on_start hook for login/setup that reschedules the simulated user if login fails, and weighted @task methods where the weight argument controls relative frequency (e.g. browsing products 3x more often than adding to cart). Response validation uses catch_response=True context managers to mark specific status codes as failures even when the HTTP call itself succeeds.

class WebsiteUser(HttpUser):
    wait_time = between(1, 3)
    @task(3)
    def view_products(self):
        self.client.get("/products")
    @task(1)
    def add_to_cart(self):
        self.client.post("/cart/add", {"product_id": random.randint(1, 50)})

Advanced behavior modeling uses SequentialTaskSet to model a complete ordered user journey (browse catalog, search, view a featured product, add to cart, and conditionally checkout for only a fraction of simulated users), assigned to an HttpUser with a relative weight versus other user types. Custom request validation covers timing-based failure (flagging responses slower than a threshold even if they returned 200), JSON content validation (checking for an error field or empty result set), and file upload testing with multipart form data. Configuration covers a locust.conf file for headless CLI parameters (user count, spawn rate, run time, target host) and environment-variable-driven host/API-key configuration set in on_start request headers.

Distributed testing runs a master node coordinating multiple worker nodes for high-scale load generation, shown both via CLI flags and a Docker Compose setup with a master service and a worker service scaled to multiple replicas. Performance monitoring integrates Locust's event hooks (events.request, events.test_start, events.init) to log failed and slow requests, log test-start context, and periodically log system CPU/memory usage via psutil during the run. Best practices cover starting with low user counts and ramping up to find breaking points, using realistic/varied test data to avoid caching skew, monitoring the load-generating client's own resource usage, validating response content and business logic (not just status codes), and modeling realistic think time and error handling.

Use this skill when writing or scaling a Locust load test - modeling weighted or sequential user behavior, validating response correctness beyond status codes, configuring headless CLI runs, scaling out with a master-worker distributed setup, or instrumenting custom performance monitoring during a test run.

It is not the right tool for teams already standardized on a different load testing tool (Gatling, JMeter, k6) where Locust's Python-based user-class model doesn't fit the existing toolchain, or for pure protocol-level testing without the need for realistic Python-scripted user journeys.

Input: the target API/application, the user journeys to simulate (single-task weighted or sequential multi-step), expected concurrency and ramp-up profile, and any custom validation logic needed. Output: a Locust locustfile.py with HttpUser/SequentialTaskSet classes, custom response validation, environment-driven configuration, distributed master-worker deployment (CLI or Docker Compose), and event-hook-based custom monitoring and logging.

Built on the Locust Python framework (HttpUser, SequentialTaskSet, events), with distributed execution via Locust's native master-worker protocol, Docker Compose for containerized scaling, and psutil for client-side resource monitoring during test runs.

Performance engineers and Python developers writing load tests that need realistic, weighted or sequential user behavior modeling - particularly teams needing distributed, high-scale load generation and custom response validation beyond basic status-code checks.