export const options = { stages: [ { duration: '30s', target: 20 }, // Ramp up { duration: '1m', target: 20 }, // Steady { duration: '30s', target: 0 }, // Ramp down ], thresholds: { http_req_duration: ['p(95)<500'], // 95% under 500ms http_req_failed: ['rate<0.01'], // <1% errors }, };

export default function () { const res = http.get('http://localhost:8500/api/health');

check(res, { 'status is 200': (r) => r.status === 200, 'response time < 200ms': (r) => r.timings.duration < 200, });

sleep(1); }


## Locust Load Test (Python)

```python
from locust import HttpUser, task, between

class APIUser(HttpUser):
    wait_time = between(1, 3)

    @task(3)
    def get_analyses(self):
        self.client.get("/api/analyses")

    @task(1)
    def create_analysis(self):
        self.client.post(
            "/api/analyses",
            json={"url": "https://example.com"}
        )

    def on_start(self):
        """Login before tasks."""
        self.client.post("/api/auth/login", json={
            "email": "test@example.com",
            "password": "password"
        })

Test Types

Load Test

// Normal expected load
export const options = {
  vus: 50,           // Virtual users
  duration: '5m',    // Duration
};

Stress Test

// Find breaking point
export const options = {
  stages: [
    { duration: '2m', target: 100 },
    { duration: '2m', target: 200 },
    { duration: '2m', target: 300 },
    { duration: '2m', target: 400 },
  ],
};

Spike Test

// Sudden traffic surge
export const options = {
  stages: [
    { duration: '10s', target: 10 },
    { duration: '1s', target: 1000 },  // Spike!
    { duration: '3m', target: 1000 },
    { duration: '10s', target: 10 },
  ],
};

Soak Test

// Sustained load (memory leaks)
export const options = {
  vus: 50,
  duration: '4h',
};

Metrics to Track

import { Trend, Counter, Rate } from 'k6/metrics';

const responseTime = new Trend('response_time');
const errors = new Counter('errors');
const successRate = new Rate('success_rate');

export default function () {
  const start = Date.now();
  const res = http.get('http://localhost:8500/api/data');

  responseTime.add(Date.now() - start);

  if (res.status !== 200) {
    errors.add(1);
    successRate.add(false);
  } else {
    successRate.add(true);
  }
}

CI Integration

# GitHub Actions
- name: Run k6 load test
  run: |
    k6 run --out json=results.json tests/load/api.js

- name: Check thresholds
  run: |
    if [ $(jq '.thresholds | .[] | select(.ok == false)' results.json | wc -l) -gt 0 ]; then
      exit 1
    fi

Key Decisions

Decision	Recommendation
Tool	k6 (JS), Locust (Python)
Load profile	Start with expected traffic
Thresholds	p95 < 500ms, errors < 1%
Duration	5-10 min for load, 4h+ for soak

Common Mistakes

Testing against production without protection
No warmup period
Unrealistic load profiles
Missing error rate thresholds

Related Skills

observability-monitoring - Metrics collection
performance-optimization - Fixing bottlenecks
e2e-testing - Functional validation

Capability Details

load-testing

Keywords: load test, concurrent users, k6, Locust, ramp up Solves:

Simulate concurrent user load
Configure ramp-up patterns
Test system under expected load

stress-testing

Keywords: stress test, breaking point, peak load, overload Solves:

Find system breaking points
Test beyond expected capacity
Identify failure modes under stress

latency-measurement

Keywords: latency, response time, p95, p99, percentile Solves:

Measure response time percentiles
Track latency distribution
Set latency SLO thresholds

throughput-testing

Keywords: throughput, requests per second, RPS, TPS Solves:

Measure maximum throughput
Test transactions per second
Verify capacity requirements

bottleneck-identification

Keywords: bottleneck, profiling, hot path, performance issue Solves:

Identify performance bottlenecks
Profile critical code paths
Diagnose slow operations

performance-testing

Performance Testing

k6 Load Test (JavaScript)