When To Use LoadStrike

Use LoadStrike when your real performance question is about a workflow across systems, not just one endpoint. It is most useful when completion happens downstream.

Guide

Best Fit

LoadStrike is a strong fit when business latency depends on more than one hop. That includes APIs that publish to Kafka, services that fan out to workers, browser journeys that trigger async processing, or any path where success is only visible later.

Team Fit

It is built for engineering, QA, platform, and SRE teams that want code-first tests, aligned SDK behavior, and one runtime and reporting model across distributed system boundaries.

When Simpler Tools Are Enough

If the workload is purely request-response and the only question is endpoint throughput or latency, an endpoint-focused tool can still be a reasonable choice. LoadStrike becomes more valuable when the system only feels complete after a correlated downstream result arrives.

Feature Usage Samples

Licensing note: every runnable sample still needs a valid runner key. Set it with WithRunnerKey("...") or the config key LoadStrike:RunnerKey before you run the test.

When LoadStrike Fits

using LoadStrike;

var source = new HttpEndpointDefinition
{
    Name = "orders-api",
    Mode = TrafficEndpointMode.Produce,
    TrackingField = TrackingFieldSelector.Parse("header:X-Correlation-Id"),
    Url = "https://api.example.com/orders",
    Method = "POST",
    MessagePayload = new { orderId = "ord-1001", amount = 49.95m }
};

var destination = new KafkaEndpointDefinition
{
    Name = "orders-completed",
    Mode = TrafficEndpointMode.Consume,
    TrackingField = TrackingFieldSelector.Parse("header:X-Correlation-Id"),
    BootstrapServers = "localhost:9092",
    Topic = "orders.completed",
    ConsumerGroupId = "loadstrike-orders"
};

var tracking = new CrossPlatformTrackingConfiguration
{
    Source = source,
    Destination = destination,
    RunMode = TrackingRunMode.GenerateAndCorrelate,
    CorrelationTimeout = TimeSpan.FromSeconds(30)
};

var scenario = CrossPlatformScenarioConfigurator
    .Configure(LoadStrikeScenario.Empty("orders-http-to-kafka"), tracking)
    .WithLoadSimulations(
        LoadStrikeSimulation.Inject(10, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(20))
    );

LoadStrikeRunner.RegisterScenarios(scenario)
    .WithRunnerKey("rkl_your_local_runner_key")
    .Run();

import com.loadstrike.runtime.CrossPlatformScenarioConfigurator;
import com.loadstrike.runtime.CrossPlatformTrackingConfiguration;
import com.loadstrike.runtime.HttpEndpointDefinition;
import com.loadstrike.runtime.KafkaEndpointDefinition;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeRunner;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeScenario;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeSimulation;
import com.loadstrike.runtime.LoadStrikeCorrelation.TrackingFieldSelector;
import com.loadstrike.runtime.LoadStrikeTransports;

var source = new HttpEndpointDefinition();
source.name = "orders-api";
source.mode = LoadStrikeTransports.TrafficEndpointMode.Produce;
source.trackingField = TrackingFieldSelector.parse("header:X-Correlation-Id");
source.url = "https://api.example.com/orders";
source.method = "POST";
source.messagePayload = java.util.Map.of("orderId", "ord-1001", "amount", 49.95);

var destination = new KafkaEndpointDefinition();
destination.name = "orders-completed";
destination.mode = LoadStrikeTransports.TrafficEndpointMode.Consume;
destination.trackingField = TrackingFieldSelector.parse("header:X-Correlation-Id");
destination.bootstrapServers = "localhost:9092";
destination.topic = "orders.completed";
destination.consumerGroupId = "loadstrike-orders";

var tracking = new CrossPlatformTrackingConfiguration();
tracking.source = source;
tracking.destination = destination;
tracking.runMode = LoadStrikeTransports.TrackingRunMode.GenerateAndCorrelate;
tracking.correlationTimeoutSeconds = 30d;

var scenario = CrossPlatformScenarioConfigurator.Configure(
    LoadStrikeScenario.empty("orders-http-to-kafka"),
    tracking
).withLoadSimulations(LoadStrikeSimulation.inject(10, 1d, 20d));

LoadStrikeRunner
    .registerScenarios(scenario)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();

from loadstrike_sdk import (
    CrossPlatformScenarioConfigurator,
    LoadStrikeRunner,
    LoadStrikeScenario,
    LoadStrikeSimulation,
)

tracking = {
    "RunMode": "GenerateAndCorrelate",
    "CorrelationTimeoutSeconds": 30,
    "Source": {
        "Kind": "Http",
        "Name": "orders-api",
        "Mode": "Produce",
        "TrackingField": "header:X-Correlation-Id",
        "Url": "https://api.example.com/orders",
        "Method": "POST",
        "MessagePayload": {"orderId": "ord-1001", "amount": 49.95},
    },
    "Destination": {
        "Kind": "Kafka",
        "Name": "orders-completed",
        "Mode": "Consume",
        "TrackingField": "header:X-Correlation-Id",
        "BootstrapServers": "localhost:9092",
        "Topic": "orders.completed",
        "ConsumerGroupId": "loadstrike-orders",
    },
}

scenario = (
    CrossPlatformScenarioConfigurator.Configure(
        LoadStrikeScenario.empty("orders-http-to-kafka"),
        tracking,
    )
    .with_load_simulations(LoadStrikeSimulation.inject(10, 1, 20))
)

LoadStrikeRunner.register_scenarios(scenario) \
    .with_runner_key("rkl_your_local_runner_key") \
    .run()

import {
  CrossPlatformScenarioConfigurator,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation,
  TrackingFieldSelector
} from "@loadstrike/loadstrike-sdk";

const tracking = {
  RunMode: "GenerateAndCorrelate",
  CorrelationTimeoutSeconds: 30,
  Source: {
    Kind: "Http",
    Name: "orders-api",
    Mode: "Produce",
    TrackingField: new TrackingFieldSelector("Header", "X-Correlation-Id"),
    Url: "https://api.example.com/orders",
    Method: "POST",
    MessagePayload: { orderId: "ord-1001", amount: 49.95 }
  },
  Destination: {
    Kind: "Kafka",
    Name: "orders-completed",
    Mode: "Consume",
    TrackingField: new TrackingFieldSelector("Header", "X-Correlation-Id"),
    BootstrapServers: "localhost:9092",
    Topic: "orders.completed",
    ConsumerGroupId: "loadstrike-orders"
  }
};

const scenario = CrossPlatformScenarioConfigurator
  .Configure(LoadStrikeScenario.empty("orders-http-to-kafka"), tracking)
  .withLoadSimulations(LoadStrikeSimulation.inject(10, 1, 20));

await LoadStrikeRunner
  .registerScenarios(scenario)
  .withRunnerKey("rkl_your_local_runner_key")
  .run();

const {
  CrossPlatformScenarioConfigurator,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation,
  TrackingFieldSelector
} = require("@loadstrike/loadstrike-sdk");

(async () => {
  const tracking = {
    RunMode: "GenerateAndCorrelate",
    CorrelationTimeoutSeconds: 30,
    Source: {
      Kind: "Http",
      Name: "orders-api",
      Mode: "Produce",
      TrackingField: new TrackingFieldSelector("Header", "X-Correlation-Id"),
      Url: "https://api.example.com/orders",
      Method: "POST",
      MessagePayload: { orderId: "ord-1001", amount: 49.95 }
    },
    Destination: {
      Kind: "Kafka",
      Name: "orders-completed",
      Mode: "Consume",
      TrackingField: new TrackingFieldSelector("Header", "X-Correlation-Id"),
      BootstrapServers: "localhost:9092",
      Topic: "orders.completed",
      ConsumerGroupId: "loadstrike-orders"
    }
  };

  const scenario = CrossPlatformScenarioConfigurator
    .Configure(LoadStrikeScenario.empty("orders-http-to-kafka"), tracking)
    .withLoadSimulations(LoadStrikeSimulation.inject(10, 1, 20));

  await LoadStrikeRunner
    .registerScenarios(scenario)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();
})();

Good fit signals

Cross-system workflows

Use LoadStrike when the workflow spans APIs, queues, services, or browser steps.

Business completion

Choose LoadStrike when the important metric is whether the transaction finishes, not only whether ingress accepted the call.

SDK parity

It is a good fit when multiple teams need the same load-testing model across different language stacks.