// CI/CD INTEGRATION · GITHUB · JENKINS · GITLAB · AZURE

Ship Faster.
Break Nothing.

Drop NexoLoad into any pipeline in minutes. The --raw flag turns your load test into a binary gate — exit 0 means deploy, exit 1 means stop.

GitHub Actions

Jenkins

GitLab CI

Azure DevOps

Lite · Pro · Titan

The --raw Flag

Two Lines. One Exit Code. Pipeline-Ready.

Add --raw to any NexoLoad command. The live dashboard and detailed summary are suppressed — perfect for non-TTY environments. NexoLoad prints exactly two machine-readable lines and exits with code 0 (PASS) or 1 (FAIL).

📤 Output Format — Sample (all editions)

# Line 1 — edition, VUs, duration NexoLoad Titan · 500 VUs · 60s # Line 2 — key metrics + result verdict TPS: 2824.0 | P95: 83.0ms | P99: 121.0ms | Errors: 0.14% | Req: 172,190 | Result: PASS

🚦 Exit Code Logic

Condition	Result	Exit Code	What Happens
Error rate ≤ 1% AND assert-status passes	PASS	0	Pipeline continues — safe to deploy
Error rate > 1%	FAIL	1	Pipeline fails — deployment blocked
--assert-status mismatch detected	FAIL	1	Pipeline fails — unexpected status codes
Both conditions triggered	FAIL	1	Pipeline fails — both reasons reported

⚙️ Flags that combine with --raw

# Assert a specific HTTP status (any other = failure) --assert-status 200 # SLA threshold (still enforced, reported in output) --sla 400 # Works across all editions ./nexoload-lite --url https://api.example.com --users 20 --duration 30 --raw ./nexoload-pro --url https://api.example.com --users 100 --duration 60 --raw --assert-status 200 ./nexoload-titan --url https://api.example.com --users 1000 --duration 60 --raw --assert-status 200 --sla 400

Pipeline Examples

Drop-In YAML for Every Platform

Copy, paste, adjust your URL and thresholds. Every example uses --raw so the pipeline fails automatically on load test failure.

How Binary Delivery Works

NexoLoad ships as a single compiled binary — no Python runtime, no pip, no dependencies. Choose the delivery model that matches your environment.

Internet

Standard / Cloud

Pull the latest binary directly from GitHub Releases on every pipeline run. Always current, zero maintenance.

curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-lite-linux \
  -o nexoload-lite
chmod +x nexoload-lite

Federal Network

Private Mirror

BJNexora pushes every release build to a private artifact server. Federal clients get credentials and use the same curl pattern — just a different host. Contact us for access →

curl -fsSL https://artifacts.bjnexora-solutions.com/nexoload/latest/nexoload-lite-linux \
  -o nexoload-lite
chmod +x nexoload-lite

Air-Gapped / SCIF

Zero Network

Commit the binary directly to your repo under bin/. No downloads, no external calls — works on physically isolated networks.

chmod +x bin/nexoload-lite
./bin/nexoload-lite \
  --url $API_URL \
  --users 20 --raw

01 GitHub Actions

YAML.github/workflows/load-test.yml
name: Load Test Gate

on:
  push:
    branches: [main, staging]
  pull_request:

jobs:
  load-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Download NexoLoad Lite
        run: |
          curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-lite-linux \
            -o nexoload-lite
          chmod +x nexoload-lite

      - name: Run NexoLoad Lite load test
        run: |
          ./nexoload-lite \
            --url ${{ secrets.API_BASE_URL }}/health \
            --users 20 \
            --duration 30 \
            --assert-status 200 \
            --raw
        # Exit code 1 = test failed = pipeline blocked

YAML.github/workflows/load-test.yml
name: Load Test Gate — Pro

on:
  push:
    branches: [main]

jobs:
  load-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Download NexoLoad Pro
        run: |
          curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-pro-linux \
            -o nexoload-pro
          chmod +x nexoload-pro

      - name: Run NexoLoad Pro load test
        run: |
          ./nexoload-pro \
            --url ${{ secrets.API_BASE_URL }}/api/v1/users \
            --method GET \
            --users 100 \
            --duration 60 \
            --rampup 15 \
            --sla 400 \
            --assert-status 200 \
            --token ${{ secrets.API_TOKEN }} \
            --raw

      - name: Upload HTML report on failure
        if: failure()
        run: |
          ./nexoload-pro \
            --url ${{ secrets.API_BASE_URL }}/api/v1/users \
            --users 50 --duration 30 \
            --html-report load-report.html
        continue-on-error: true

      - name: Attach report artifact
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: load-test-report
          path: load-report.html

YAML.github/workflows/load-test-titan.yml
name: Load Test Gate — Titan (10,000+ VUs)

on:
  push:
    branches: [main]

jobs:
  titan-load-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Download NexoLoad Titan
        run: |
          curl -L https://github.com/your-org/nexoload/releases/latest/download/nexoload-titan-linux \
            -o nexoload-titan
          chmod +x nexoload-titan

      - name: Run Titan high-concurrency load test
        run: |
          ./nexoload-titan \
            --url ${{ secrets.API_BASE_URL }}/api/v1/endpoint \
            --users 1000 \
            --duration 60 \
            --rampup 20 \
            --sla 400 \
            --sla-tps 500 \
            --assert-status 200 \
            --no-verify-ssl \
            --raw

02 Jenkins

GroovyJenkinsfile
pipeline {
    agent any

    environment {
        API_URL = credentials('api-base-url')
    }

    stages {
        stage('Load Test') {
            steps {
                sh """
                    curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-lite-linux -o nexoload-lite
                    chmod +x nexoload-lite
                    ./nexoload-lite \\
                        --url \${API_URL}/health \\
                        --users 20 \\
                        --duration 30 \\
                        --assert-status 200 \\
                        --raw
                """
            }
        }

        stage('Deploy') {
            steps {
                echo 'Load test passed — deploying...'
                // your deploy steps here
            }
        }
    }

    post {
        failure {
            echo 'Load test FAILED — deployment blocked'
            emailext subject: 'Load Test Failed',
                     body: 'NexoLoad detected failures. Check build logs.',
                     to: 'devops@yourcompany.com'
        }
    }
}

GroovyJenkinsfile
pipeline {
    agent any

    environment {
        API_URL   = credentials('api-base-url')
        API_TOKEN = credentials('api-token')
    }

    stages {
        stage('Load Test — NexoLoad Pro') {
            steps {
                sh """
                    curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-pro-linux -o nexoload-pro
                    chmod +x nexoload-pro
                    ./nexoload-pro \\
                        --url \${API_URL}/api/v1/orders \\
                        --method POST \\
                        --body '{"test":true}' \\
                        --users 100 \\
                        --duration 60 \\
                        --rampup 15 \\
                        --sla 400 \\
                        --assert-status 200 \\
                        --token \${API_TOKEN} \\
                        --raw
                """
            }
        }

        stage('Deploy to Production') {
            steps {
                sh './deploy.sh production'
            }
        }
    }
}

GroovyJenkinsfile
pipeline {
    agent any

    environment {
        API_URL = credentials('api-base-url')
    }

    stages {
        stage('High-Concurrency Load Test — Titan') {
            steps {
                sh """
                    curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-titan-linux -o nexoload-titan
                    chmod +x nexoload-titan
                    ./nexoload-titan \\
                        --url \${API_URL}/api/v1/feed \\
                        --users 5000 \\
                        --duration 60 \\
                        --rampup 30 \\
                        --sla 500 \\
                        --assert-status 200 \\
                        --raw
                """
            }
        }

        stage('Blue-Green Switch') {
            steps {
                sh './switch-traffic.sh blue green'
            }
        }
    }
}

03 GitLab CI

YAML.gitlab-ci.yml
stages:
  - test
  - load-test
  - deploy

load-test-lite:
  stage: load-test
  image: alpine
  before_script:
    - apk add --no-cache curl
    - curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-lite-linux -o nexoload-lite
    - chmod +x nexoload-lite
  script:
    - ./nexoload-lite
        --url $API_BASE_URL/health
        --users 20
        --duration 30
        --assert-status 200
        --raw
  rules:
    - if: '$CI_COMMIT_BRANCH == "main"'

deploy-production:
  stage: deploy
  script:
    - ./deploy.sh
  needs: [load-test-lite]
  rules:
    - if: '$CI_COMMIT_BRANCH == "main"'

YAML.gitlab-ci.yml
stages:
  - unit-test
  - load-test
  - deploy

load-test-pro:
  stage: load-test
  image: alpine
  variables:
    USERS: '100'
    DURATION: '60'
  before_script:
    - apk add --no-cache curl
    - curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-pro-linux -o nexoload-pro
    - chmod +x nexoload-pro
  script:
    - ./nexoload-pro
        --url $API_BASE_URL/api/v1/items
        --users $USERS
        --duration $DURATION
        --rampup 15
        --sla 400
        --assert-status 200
        --token $API_TOKEN
        --raw
  artifacts:
    when: always
    expire_in: 7 days
  rules:
    - if: '$CI_COMMIT_BRANCH == "main"'

YAML.gitlab-ci.yml
stages:
  - load-test
  - promote

titan-stress-test:
  stage: load-test
  image: alpine
  before_script:
    - apk add --no-cache curl
    - curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-titan-linux -o nexoload-titan
    - chmod +x nexoload-titan
  script:
    - ./nexoload-titan
        --url $API_BASE_URL/api/v1/stream
        --users 5000
        --duration 120
        --rampup 30
        --sla 500
        --sla-tps 1000
        --assert-status 200
        --warmup 10
        --raw
  rules:
    - if: '$CI_PIPELINE_SOURCE == "schedule"'
      # Run nightly at scale — triggered by a GitLab scheduled pipeline

04 Azure DevOps

YAMLazure-pipelines.yml
trigger:
  branches:
    include: [main, release/*]

pool:
  vmImage: ubuntu-latest

variables:
  API_URL: $(API_BASE_URL)

steps:
- script: |
    curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-lite-linux \
      -o nexoload-lite
    chmod +x nexoload-lite
  displayName: 'Download NexoLoad Lite'

- script: |
    ./nexoload-lite \
      --url $(API_URL)/health \
      --users 20 \
      --duration 30 \
      --assert-status 200 \
      --raw
  displayName: 'NexoLoad Load Test Gate'
  failOnStderr: false

YAMLazure-pipelines.yml
trigger:
  branches:
    include: [main]

pool:
  vmImage: ubuntu-latest

steps:
- script: |
    curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-pro-linux \
      -o nexoload-pro
    chmod +x nexoload-pro
  displayName: 'Download NexoLoad Pro'

- script: |
    ./nexoload-pro \
      --url $(API_BASE_URL)/api/v1/products \
      --method GET \
      --users 100 \
      --duration 60 \
      --rampup 15 \
      --sla 400 \
      --assert-status 200 \
      --token $(API_TOKEN) \
      --raw
  displayName: 'NexoLoad Pro Load Test'

- script: echo "Load test passed — proceeding to deploy"
  displayName: 'Deploy'
  condition: succeeded()

YAMLazure-pipelines.yml
trigger: none
schedules:
- cron: "0 2 * * *"   # Nightly at 2am UTC
  displayName: Nightly Titan Stress Test
  branches:
    include: [main]

pool:
  vmImage: ubuntu-latest

steps:
- script: |
    curl -fsSL https://github.com/bjnexora/nexoload/releases/latest/download/nexoload-titan-linux \
      -o nexoload-titan
    chmod +x nexoload-titan
  displayName: 'Download NexoLoad Titan'

- script: |
    ./nexoload-titan \
      --url $(API_BASE_URL)/api/v1/search \
      --users 5000 \
      --duration 120 \
      --rampup 30 \
      --warmup 10 \
      --sla 500 \
      --sla-tps 2000 \
      --assert-status 200 \
      --raw
  displayName: 'Titan Nightly Stress Test'

Pro Tips

Get More from Your Pipeline

🔐

Store URLs as secrets

Never hardcode staging or production URLs in YAML. Use pipeline secrets / environment variables and reference them as ${{ secrets.API_URL }} (GitHub) or $(API_URL) (Azure).

⏫

Scale up for release gates

Use Lite (--users 20) on every PR for fast feedback. Run Pro or Titan (--users 1000+) only on main branch merges or release candidates.

🌡️

Always use --rampup

Starting 1,000 VUs simultaneously hits the server cold. Use --rampup 30 to gradually add users over 30 seconds — mimics real traffic spikes and avoids false failures.

♨️

Warmup for cache-sensitive APIs

Titan's --warmup 10 fires requests for 10 seconds before counting results — lets caches warm up and JIT compile so you measure steady-state, not cold-start.

📊

Save HTML reports on failure

Run --html-report report.html in a follow-up step that only triggers on failure. Upload as an artifact so engineers can debug from the full report without re-running.

🌙

Schedule nightly Titan runs

Use Titan at full scale on a nightly cron — --users 5000 --duration 120 — to catch regressions before they reach production. Run Lite on every push to keep CI fast.

Live Validation Example

Sample CI/CD Runbook

Review a real NexoLoad validation run using AWS API Gateway + Lambda — including smoke testing, forced failure validation, auth checks, and CI/CD gate behavior.

View Sample Runbook →

// Coming in v1.0 · Federal-scale async engine

NexoLoad Titan
10,000+ VUs. One Machine.

When your CI/CD pipeline needs more than 200 concurrent users, Titan is the answer. Same binary, same flags as Pro — asyncio engine that scales to 10,000+ VUs with near-zero RAM overhead.

Explore Titan →

10,000⁺Concurrent VUs

2,824Target TPS · Fall 2026

83_msP95 Latency

10_KBRAM per VU

Ready to Add NexoLoad to Your Pipeline?

Start with a free Lite trial — no credit card, zero install, self-contained binary.

Request Free Trial → View All Editions