See loadr work

10 VUs against one endpoint for 30s, with checks and a pass/fail threshold.

Climb to 50 VUs, hold, ramp down — with human-like think time.

Hold exactly 100 req/s regardless of how slowly the target responds.

Calm baseline, sudden 10× spike, recovery — abort if errors explode.

Hold steady for the long haul and stream metrics to a time-series store.

70% browse, 20% search, 10% checkout — one scenario, weighted branches.

Loops, conditionals, groups and weighted tasks inside a single flow.

Feed data from CSV/JSON per iteration and cap per-VU request rate.

Parameterise every request from a CSV/JSON dataset.

Pull a token/id out of one response and feed it into the next.

One pass over a case table; fail the run on any failed assertion.

Chain extract-and-assert steps that short-circuit on the first miss.

Group failures by root cause instead of one undifferentiated error count.

Tag requests and scenarios to slice every metric by route or group.

A capturing HTTP(S) proxy turns a real journey into a correlated scenario.

OpenAPI, Postman, GraphQL or gRPC in — a runnable, fuzzed scenario out.

A deterministic root-cause read of any run — no model, no network.

A local run history + a robust MAD z-score against a window, not one baseline.

Each VU mints its own token and silently refreshes it before expiry.

A per-VU cookie jar carries a login session across the whole flow.

POST a multipart/form-data body mixing literal fields with a file part.

Redirects, retries, timeouts, headers and body shapes in depth.

Open a socket, send and receive frames, assert on messages.

Unary and streaming gRPC calls from a .proto, no codegen step.

Queries and mutations with variables, over HTTP.

Send bytes over a raw socket and match the response.

Subscribe to an event stream and assert on events over time.

Raw SOAP envelope in, XPath extraction and assertions out.

Twirp over HTTP/JSON — a call is just a POST, no codegen.

Drive a real headless browser page for front-end journeys.

Parameterised SELECT / INSERT / UPDATE — the query is the request.

insert / find / update / aggregate — one operation per request.

One query per request over the MySQL wire protocol.

Speak RESP over TCP — SET, GET, INCR, EXPIRE, one command per request.

Produce and fetch against a broker — pure Rust, no librdkafka.

Publish and consume over AMQP 0.9.1, declaring queues inline.

index / get / search / bulk over the HTTP/JSON API.

Drop into JS for logic the YAML doesn't cover — right inside a flow.

Declare counter / rate / trend / gauge metrics and emit from JS.

setup / teardown and per-VU init around the load.

One controller fans a single plan out across many agents.

One plan, many targets — swap base URLs and secrets per environment.

Run several named scenarios at once and roll requests into groups.

A self-contained HTML report with the whole run's curves.

Stream metrics to Prometheus and watch the run in a ready-made dashboard.

A perf smoke test wired into GitHub Actions that fails the build on regression.

Run the controller + agent fleet as a Kubernetes Job.

Convert an existing k6 script or JMeter .jmx into a loadr plan.

Drive a run from the browser and watch percentiles, throughput and errors live.

Watch a distributed controller + agents drive one run from the Web UI.

Ship a new protocol as a native plugin — here, a Go echo server driver.

Drive a C echo server through a hand-written native protocol plugin.