Overview

Relampo YAML is the durable source of truth for test definitions. This page explains what the format is for, how it fits into the product workflow, and what a valid file generally looks like.

What the YAML is for

Use Relampo YAML to define:

• test metadata
• reusable variables
• shared HTTP defaults
• scenarios and load behavior
• ordered request steps
• dynamic value extraction and reuse

This is the file format consumed by the CLI runtime and used as the editable artifact across the Relampo workflow.

Where it fits in the flow

Relampo YAML sits at the center of the main authoring and execution pipeline:

1. record captures traffic and generates a YAML baseline.
2. correlate analyzes dynamic values and can update the YAML with extractors and placeholders.
3. run executes the YAML as the source of truth.
4. debug helps troubleshoot runtime failures and correlation issues.

The YAML file is therefore both:

• a human-maintained test artifact
• a machine-executed scenario definition

Canonical shape

A typical Relampo YAML file follows this structure:

test:
  name: "Test Name"
  description: "Optional description"
  version: "1.0"

variables:
  key: value

data_source:
  type: csv
  file: data.csv
  bind:
    var_name: column_name

http_defaults:
  base_url: "https://api.example.com"
  timeout: "30s"
  headers:
    Accept: "application/json"

scenarios:
  - name: "Scenario Name"
    load:
      type: constant
      users: 10
      duration: 5m
    steps:
      - request: ...
      - think_time: ...

Minimum practical sections

In practice, the most important blocks are:

• test
• http_defaults (common in maintainable scripts)
• scenarios
• steps

Other sections such as variables, data_source, assertions, and extractors become important as the script becomes more reusable and realistic.

Authoring model

Relampo YAML is designed to be:

• human-readable
• version-control friendly
• stable enough for automation
• editable both manually and through Relampo tooling

A script can start as generated output, then evolve into a maintained artifact through manual edits and correlation updates.

Good usage pattern

A clean authoring pattern is:

1. Generate the initial script through tooling.
2. Normalize names and structure.
3. Apply correlation where needed.
4. Validate after meaningful edits.
5. Keep the YAML under version control.

What to read next

• Go to Reference for the field-by-field structure.
• Go to Compatibility for differences between handwritten and generated YAML.
• Go to Validation for what --validate checks and what it does not.