Leveraging Gatling for GitOps-driven load testing | Datasheet
Datasheet · GitOps

Leveraging Gatling for GitOps-driven load testing: performance as code, from commit to production

Automate test environments, enforce performance gates, and deliver reliable applications at scale with Gatling Enterprise Edition. For platform, QA, and SRE teams.

Performance testing, the last manual step

Your pipeline is automated. Your load tests should be too.

Modern DevOps teams have automated nearly every part of delivery: builds, deployments, observability, even infrastructure provisioning. Performance testing is often the exception: manual, detached, and inconsistent.

As organizations adopt GitOps, it's time to bring the same principles (version control, declarative state, automation, and auditability) to load testing.

Gatling Enterprise Edition makes load tests first-class citizens of the delivery workflow: written as code, versioned in Git, run automatically in CI/CD, with load testing infrastructure managed declaratively as code. The result is safer releases, faster feedback, and measurable reliability gains.

From infrastructure to everything as code

GitOps: Git as the single source of truth

GitOps isn't a product. It's an operating model where every piece of operational state (application configuration, infrastructure, policies, and deployment definitions) lives as code in Git.

Each change follows the same lifecycle as application code: proposed in a pull request, reviewed, and applied automatically by a reconciler or CI/CD system. The system stays auditable, version-controlled, and self-healing, always converging on its declared state.

Why GitOps for load testing?

Traditional load testing depends on manual runs, isolated tools, and static staging environments that don't reproduce real conditions. The result: brittle feedback loops, false positives, and regressions found too late. A GitOps approach applies the rigor of deployment automation:

Versioned

Simulations, configurations, and thresholds live in Git and are reviewed like any other source artifact.

Automated

Every merge, tag, or deployment can trigger performance tests in CI/CD.

Declarative

Test environments, infrastructure, and datasets are provisioned as code, so runs are reproducible.

Observable

Results flow automatically to APM and observability tools, dashboards, and monitoring, closing the loop.

Core capabilities

What makes GitOps load testing work in Gatling Enterprise Edition

01

Test as code

Simulations are written in JavaScript, TypeScript, Scala, Java, or Kotlin. Each one describes the user journey, the data feeders, the injection profile, and the assertions that define acceptable performance.

  • Traceability: every change is linked to a commit, with full history and rollback
  • Collaboration: developers, SREs, and QA review changes through standard Git workflows
  • Reproducibility: a simulation behaves the same locally, in CI, or on distributed infrastructure
  • Automation: tests run automatically on pull requests or before deployments

Load tests evolve at the same speed as the codebase and stay aligned with the release cadence.

Example: a simulation with performance gates (JavaScript)
import { constantUsersPerSec, global, scenario, simulation } from "@gatling.io/core"; import { http } from "@gatling.io/http"; export default simulation((setUp) => { // Define HTTP configuration const httpProtocol = http .baseUrl("https://api-ecomm.gatling.io") .acceptHeader("application/json"); // Define scenario const scn = scenario("Scenario").exec(http("Session").get("/session")); // Injection profile, plus assertions that act as performance gates setUp(scn.injectOpen(constantUsersPerSec(2).during(60))) .protocols(httpProtocol) .assertions( global().responseTime().percentile(95.0).lt(500), global().failedRequests().percent().lt(1.0) ); });
02

Configuration as code

Beyond simulation logic, test configuration is declared in a descriptor file (typically .conf) that works as a manifest for the whole execution context:

What runs

The simulations and packages to include, with input datasets and feeder definitions.

How it runs

Load profiles, durations, pacing, and environment variables such as base URLs, API keys, or credentials.

Where it runs

Load generator topology, regional distribution, and resource allocation.

Stored in Git, every test becomes versioned, reviewable, and reproducible, behaving the same on workstations, in CI, and in pre-production. No more "works on my machine."

03

Build from Git

In GitOps, the repository defines everything needed to build, test, and deploy. Build from Git extends that to performance validation: Gatling Enterprise Edition pulls simulations and configurations straight from GitHub, GitLab, Bitbucket, or equivalent, with no packaging step.

1 · Reference

Point Gatling Enterprise Edition at the repository and branch.

2 · Build and run

On each commit or merge, it pulls the source, builds the artifact, and runs the test in the defined environment.

3 · Enforce

Assertions and stop criteria apply pass or fail logic automatically.

Each run can be tied to a specific commit, so performance metrics trace back to the exact code that produced them.

04

Infrastructure as code

Manage load testing infrastructure with the same declarative tools you use in production: Terraform, AWS CloudFormation, or Helm charts for Kubernetes.

  • Private locations for secure, self-hosted load generation
  • Load generators across multiple cloud regions
  • Network and resource specs such as CPU, memory, and bandwidth

This enables ephemeral test environments: short-lived, isolated setups created automatically to validate a pull request or pre-production deployment, then destroyed. Infrastructure stays predictable, cost-efficient, and policy-compliant.

Example: a private location on AWS (Terraform)
module "location" { source = "git::https://github.com/gatling/gatling-enterprise-control-plane-deployment//terraform/aws/location" id = "prl_aws" description = "Private Location on AWS" region = "<Region>" subnets = ["<SubnetId>"] security-groups = ["<SecurityGroupId>"] }
GitOps-ready continuous load testing

Continuous, declarative, and fully traceable

Traceable results

Every run, linked to a commit

Dashboards with trend and comparison views track regressions across branches and verify SLO compliance. Integrations with Datadog and Dynatrace correlate test metrics with infrastructure telemetry to speed up root-cause analysis.

CI/CD automation

Native to your pipelines

Works with GitHub Actions, GitLab CI, Jenkins, and more, configured in YAML or triggered by API.

  • Post-deployment smoke tests
  • Nightly regression tests
  • Pre-release stress validation
Performance governance

Thresholds as policy

Assertions on latency percentiles, throughput, error rates, or success ratios fail the pipeline when breached, blocking promotion. Performance becomes a governed policy, versioned and enforced like any compliance check.

Gatling Enterprise Edition

Choosing the right platform for modern load testing

With simulations, configurations, and infrastructure all expressed as code and governed by the same workflows as application delivery, results trace from commit to performance impact, and reliability grows in step with speed.

Analyze smarter and act faster

Real-time visibility with dashboards, trend comparisons, and actionable insights.

Create tests your way

Code, low-code, or no-code: script in JavaScript, TypeScript, or Java, import Postman, or design visually.

Unlock automation

Trigger simulations from CI/CD or the API, apply stop criteria, and gate releases with performance thresholds.

Collaborate and share results

RBAC, SSO, quotas, and shared reports. Share results in Slack, Teams, or Jira.

Deploy load generators anywhere

Run tests from Gatling-managed regions, your own cloud, or on-prem.

Ready to evaluate Enterprise Edition?

Keep the datasheet, or see it in action

Take the GitOps load testing guide to your platform team, or see Build from Git and performance gates in a live session.

Download

Get the full datasheet

Test as code, configuration as code, Build from Git, and infrastructure as code, with examples.

PDF · free, no formDownload the PDF
Live session

See Gatling Enterprise Edition live

A guided walkthrough with a Gatling engineer, with time for your questions.

Join the next live session