OpenLoad

A full-stack load-testing analytics platform that helps teams measure, visualize, and optimize API performance under load.

What is OpenLoad?

OpenLoad is a modern load-testing analytics tool designed to:

Create and manage load tests for HTTP and WebSocket services (gRPC, GraphQL, SOAP architecture in place)
Prepare reusable datasets for parameterized load tests — collect rows from APIs and inject them as variables
Schedule automated tests with cron expressions for continuous performance monitoring
Organize tests by projects and services for better scalability tracking
Capture detailed metrics from test runs (response times, throughput, error rates)
Visualize performance trends with percentile-based analytics (p50, p75, p95, p99)
Track historical data to compare performance across test runs

Quick Start

Note: This project uses Reflex 0.9.0+. See Development Requirements below for compatibility notes on icon naming, component API changes, and port configuration.

Option 1: Docker Compose (Recommended)

cd deployment/
docker compose up -d

Services:

Frontend: http://localhost:8180 (Reflex UI)
Backend API: http://localhost:8182 (Fiber server)
Backend Health Check: http://localhost:8182/health
PostgreSQL: localhost:5432
ClickHouse: localhost:9001

The frontend auto-migrates the database schema and loads sample data on first run.

Stop services:

docker compose down

Rebuild after code changes:

docker compose build
docker compose up -d

Option 2: Local Development

Backend (Go) — from `openload_back/`

make build       # Compile binary
make run         # Run with live reloading
make test        # Run all tests
make clean       # Clean build artifacts

The Fiber server listens on http://localhost:8182.

Frontend (Python/Reflex) — from `openload_front/`

pip install -r requirements.txt
reflex init      # One-time setup
reflex run       # Start dev server (auto-compiles on change)

The Reflex dev server listens on http://localhost:8180.

Option 3: Docker Databases + Local Code

# Start only databases
cd deployment/
docker compose up -d postgres clickhouse

# Then run backend/frontend locally (Option 2)

Development Requirements

Runtime Versions

Component	Version	Notes
Go	1.26	Uses `log/slog`, `slices`, `cmp`, and built-in `max`/`min`
Python	3.14	Uses `match`/`case` structural pattern matching
Reflex	0.9.0+	See compatibility notes below

Reflex 0.9.0+ Compatibility

This project uses Reflex 0.9.0+. The upgrade introduced breaking changes:

Icon naming: Icon names use underscores per Lucide convention (e.g., message_circle_check not check-circle)
Callout component: Requires named parameters: rx.callout(text=..., icon=..., color_scheme=...)
Port configuration: In dev mode, frontend and backend must run on different ports — use --env dev in Docker, not --env prod

Architecture

graph TB
    Client["Browser Client"]
    Frontend["Reflex Frontend<br/>(Python)"]
    Backend["Fiber API Server<br/>(Go)"]
    PG["PostgreSQL<br/>(Projects, Services, Datasets)"]
    CH["ClickHouse<br/>(Timeseries Analytics)"]

    Client -->|HTTP| Frontend
    Frontend -->|HTTP API| Backend
    Backend -->|SQL| PG
    Backend -->|Timeseries| CH

    style Client fill:#e1f5ff
    style Frontend fill:#fff3e0
    style Backend fill:#f3e5f5
    style PG fill:#e8f5e9
    style CH fill:#e8f5e9

Backend (Go) — Clean Architecture with DDD

Framework: Fiber v3 HTTP server
Database: PostgreSQL for metadata, ClickHouse for analytics
Architecture: 4-layer clean architecture (domain → application → infrastructure → delivery)
Protocols: HTTP (fully implemented), WebSocket (fully implemented), gRPC/GraphQL/SOAP (stubs registered)
Scheduling: Background cron scheduler (infrastructure/scheduler/) for automated test execution
Location: openload_back/

Frontend (Python/Reflex) — Layered Modular Architecture

Framework: Reflex 0.9+ (reactive Python → compiled React)
Location: openload_front/openload/
Layers:
- core/api/ — per-domain HTTP clients returning typed Pydantic models
- core/services/ — thin wrappers over API clients
- core/protocols/ — load-test protocol plugin system (HTTP, WebSocket, gRPC)
- shared/models/ — Pydantic models for all API types (entities, responses)
- shared/components/ — common UI (sidebar, charts, cards, badges)
- states/ — one state class per feature
- pages/ — thin routing layer, one subdirectory per route group

Data Flow

sequenceDiagram
    User->>Frontend: Create/Run Test
    Frontend->>Backend: HTTP Request
    Backend->>PG: Store Project/Service Metadata
    Backend->>ClickHouse: Write Analytics Data
    Backend->>Frontend: Return Results
    Frontend->>User: Display Metrics & Charts

Core Features

🏗️ Projects & Services

Organize load tests by projects (e.g., "Mobile API")
Define services within projects (e.g., "User Auth", "Payment Gateway")
Editable service identifiers and metadata
HTTP and WebSocket protocols fully supported; gRPC/GraphQL/SOAP architecture in place

🗄️ Prepare Data (Datasets)

Collect rows from APIs using configurable routes and extractors (JSONPath or regex)
Two collection modes: repeat (N iterations of main routes) or batch (fetch a JSON array, one row per element)
Pre/post routes: Run setup/teardown HTTP calls around data collection (e.g., auth → collect → logout)
Preview: Test collection with a single iteration before committing to a full run
Dataset injection: Select a completed dataset in the load-test wizard; its columns become injectable variables in route templates
Versioning: Each re-run increments the dataset version; previous runs are auditable
Scoping: Global or project/service-scoped datasets with owner/team visibility
SSRF protection: Two-layer defense — pre-flight DNS validation + DialContext re-validation at TCP connect

📊 Analytics & Metrics

Response time percentiles: p50, p75, p95, p99
Throughput tracking: Requests per second
Error analysis: Failure rates and error categorization
Historical comparison: Track performance across test runs

📈 Visualization

Line charts for response time trends
Throughput over time
Error rate dashboards
Run-to-run performance comparison

⚙️ Test Management

Create and configure load tests
Execute tests against multiple services
View detailed run history
Link runs to projects and services for better organization

⏰ Scheduled Testing

Automated execution: Schedule load tests with cron expressions
Continuous monitoring: Run tests automatically on defined schedules
Execution history: Track all triggered runs and their results
Active/Inactive control: Enable/disable without deleting configuration
Edit Scheduled Jobs: Update run configurations without recreating the schedule

🔀 Scenarios, Variable Extraction & Injection

Pre/post scenarios: Setup (extract tokens, login) → Main routes → Cleanup
Variable extraction: JSONPath and regex-based extraction from response bodies/headers
Variable injection: Inject extracted variables into path params, query params, headers, and request body
Per-VU isolation: Each virtual user maintains its own variable scope across iterations
Template syntax: {{varname}} placeholders in URLs, headers, and bodies; builtins: {{uuid}}, {{timestamp}}, {{random_int:1:100}}, {{random_string:8}}

🔌 WebSocket Protocol Support

Connection persistence: Single WebSocket connection per VU for the entire test duration
Message throughput testing: Configurable intervals and read timeouts for round-trip latency measurement
Response validation: Exact string / regex / JSONPath validation per message
Variable support: Extract from and inject variables into WebSocket messages
Mixed scenarios: HTTP pre/post scenarios with WebSocket main routes
Connection pooling: Reuse connections across routes with the same target URL
Failure tolerance: Configurable failure percentage threshold (default 5%)
Warmup support: RPS and Workers mode warmup for both HTTP and WebSocket tests

📄 Pagination & Filtering

Server-side pagination with dynamic filtering (search, status, project, service)
Smart sorting by date, name, or status

🔄 Comparative Analysis

Side-by-side run comparison: Compare multiple runs to identify performance regressions
Delta metrics: Percentage changes relative to a baseline (green = improved, red = degraded)
Baseline selection: Set any run as baseline
Multi-metric trends: avg, mean, max, min, p50/p75/p95/p99, req/s, error rates aggregated by date
Cross-page selection: Select runs from analytics, scheduled runs, and service history pages
Optimized data fetching: Batch API endpoint reduces N×2 sequential requests to 1

Project Structure

openload/
├── deployment/                 # Docker Compose, Dockerfiles
│
├── openload_back/              # Go backend (Fiber + Clean Architecture)
│   ├── cmd/main/               # Entry point
│   ├── internal/
│   │   ├── domain/             # Pure business logic (no external deps)
│   │   │   ├── dataset/        # Dataset entity, repo interface, status constants
│   │   │   ├── execution/      # Runner interface, plan, injector
│   │   │   ├── project/        # Project aggregate, errors
│   │   │   └── scheduled/      # Scheduled run entity
│   │   ├── application/        # Use cases, DTOs, orchestration
│   │   │   ├── analytics/      # Run creation, progress, error events
│   │   │   ├── dataset/        # Dataset CRUD, execution, extraction, SSRF guard
│   │   │   ├── project/        # Project/service use cases
│   │   │   └── scheduled/      # Scheduled run use cases
│   │   ├── infrastructure/
│   │   │   ├── execution/      # Protocol runners (HTTP ✅, WebSocket ✅, gRPC stub)
│   │   │   ├── persistence/    # PostgreSQL + ClickHouse repositories
│   │   │   └── scheduler/      # Cron-based background scheduler
│   │   └── delivery/http/      # Fiber handlers, router (thin adapter layer)
│   └── Makefile
│
├── openload_front/             # Python frontend (Reflex)
│   ├── openload/
│   │   ├── core/
│   │   │   ├── api/            # Per-domain HTTP clients (_base, analytics, project, scheduled, prepare_data)
│   │   │   ├── services/       # Service wrappers (analytics, project, scheduled)
│   │   │   └── protocols/      # Load-test protocol plugins (HTTP, WebSocket, gRPC)
│   │   ├── shared/
│   │   │   ├── components/     # Common UI (sidebar, charts, cards, badges, text)
│   │   │   ├── models/         # Pydantic models (entities, responses, prepare_data, load_test_config)
│   │   │   ├── utils/          # format_date, parse_query_param, validation helpers
│   │   │   └── constants/      # Routes, filter values, run statuses
│   │   ├── states/             # One state class per feature
│   │   │   ├── analytics_state.py
│   │   │   ├── compare_state.py / compare_selection_state.py
│   │   │   ├── dataset_state.py
│   │   │   ├── load_test_state.py
│   │   │   ├── prep_data_state.py / prep_data_wizard_state.py
│   │   │   ├── project_state.py
│   │   │   ├── run_analytics_state.py
│   │   │   ├── scheduled_state.py
│   │   │   └── sidebar_state.py
│   │   └── pages/              # Thin routing layer
│   │       ├── analytics/      # Run list
│   │       ├── analytics_run/  # Single run detail + live polling
│   │       ├── compare/        # Side-by-side comparison
│   │       ├── create_test/    # Load-test wizard (HTTP, WebSocket, gRPC tabs)
│   │       ├── prepare_data/   # Dataset list, detail, create wizard, route editor
│   │       ├── project_detail/ / service_detail/
│   │       └── scheduled_runs/ # List, detail, edit
│   └── requirements.txt
│
└── docs/

Key Concepts

Concept	Purpose
Project	Top-level container (e.g., "E-Commerce Platform")
Service	API endpoint definition under a project (HTTP URL or gRPC method)
Run	A single load test execution with captured metrics
Dataset	A reusable collection of rows gathered from APIs, injected as variables during load tests
Analytics	Time-series data: response times, throughput, errors

Roadmap

Completed

✅ Project and service management
✅ Load test creation and execution (HTTP fully implemented)
✅ Response time analytics with percentiles (p50, p75, p95, p99)
✅ Single-run metrics dashboard and charts
✅ Clean architecture refactor (domain → application → infrastructure → delivery)
✅ Run-Project-Service Linking
✅ Improved Analytics Page with split-panel sidebar filters
✅ Server-Side Pagination with dynamic filtering and sorting
✅ Scheduled Tests with cron expressions and execution history
✅ Edit Scheduled Jobs
✅ Batch Run Fetching (87% faster comparative load)
✅ Database Performance: indexed queries, connection pooling
✅ Comparative Analysis with delta metrics, baseline selection, trend charts
✅ Cross-Page Run Selection
✅ Test Scenarios & Variable Extraction/Injection (pre/post scenarios, JSONPath/regex)
✅ Per-VU Variable Isolation
✅ WebSocket Protocol Support (throughput, validation, extraction, warmup)
✅ Real-Time Live Statistics (2s polling, auto-redirect, progress snapshots)
✅ Prepare Data (Datasets): API-driven row collection, repeat/batch modes, dataset injection into load tests, SSRF protection, preview, versioning
✅ Frontend architecture refactor: states → states/, typed Pydantic API layer, split per-domain clients
✅ Runtime version bump: Go 1.26, Python 3.14
✅ Go modernization: log/slog structured logging, slices package, cmp.Compare, built-in max/min
✅ Python modernization: match/case pattern matching across state dispatchers
✅ Centralized HTTP error handling via WriteError across all handlers

2026 Roadmap

Analysis & Debugging

Export & Reports: PDF/CSV export of complete run results
- Backend: PDF generation with summary, histograms, error logs, timeseries charts
- Frontend: Export buttons on run detail page

Intelligence & Automation

Performance Regression Detection: Automatic detection of degradation vs baseline
- Compare current run against median of last 5 successful runs
- Flags response time, error rate, and throughput per route with % delta
- Essential for scheduled runs continuous monitoring

Multi-Tenancy & Security

Multi-user / Teams with RBAC: Team-based project management
- Backend: User table, JWT auth, granular project permissions
- Frontend: Login page, team selector, project sharing, audit trail
- Note: Breaking API change; requires database migration planning

Contributing

Backend (Go)

Follow clean architecture: Domain → Application → Infrastructure → Delivery
Keep domain layer free of external dependencies
Implement repository interfaces in infrastructure layer
Add protocol runners to internal/infrastructure/execution/ (implement domain.execution.Runner)
Register new runners in cmd/main/main.go
Use status constants from domain packages (e.g., domdataset.StatusDraft) — never string literals
Use log/slog for structured logging — slog.Info/Warn/Error("message", "key", value), never log.Printf
Use slices.Sort / slices.SortFunc / slices.Contains from the slices package instead of the sort package
Use cmp.Compare in slices.SortFunc comparators — never subtract integers (overflow risk)
Use the built-in max/min functions (Go 1.21+) — no manual helpers needed
Return WriteError(c, err) from handlers for consistent HTTP error responses — no ad-hoc c.Status(...).JSON(...) on error paths
Run make test before committing; ensure go build ./... passes

Frontend (Python/Reflex)

Add new state classes to states/ following existing patterns
Add new API methods to the appropriate client in core/api/; return typed Pydantic models, never raw dicts
Add new protocol UI plugins to core/protocols/ (implement ProtocolPlugin base class)
Use shared/models/ for new Pydantic entity and response models
Use shared/ for truly cross-feature components
All imports must be at module level (enforced by Ruff E402)
Use match/case for dispatching on string values — replace if/elif chains on active_tab, kind, sort_by, etc.
Use rx.match() instead of nested rx.cond() for pattern matching in templates
Follow copy-mutate-reassign for list state mutations (deepcopy for nested structures)
Run reflex compile and ./fix-python.bat --check before committing

Code Quality

Python (Frontend):

cd openload_front
./fix-python.bat --check  # Windows
./fix-python.sh --check   # macOS/Linux

Go (Backend):

cd openload_back
make test    # All tests must pass
make build   # Must compile without errors

Name		Name	Last commit message	Last commit date
Latest commit History 93 Commits
.github/instructions		.github/instructions
assets		assets
deployment		deployment
docs		docs
openload_back		openload_back
openload_front		openload_front
.gitignore		.gitignore
.pre-commit-config.yaml		.pre-commit-config.yaml
README.md		README.md

Folders and files

Latest commit

History

Repository files navigation

OpenLoad

What is OpenLoad?

Quick Start

Option 1: Docker Compose (Recommended)

Option 2: Local Development

Backend (Go) — from openload_back/

Frontend (Python/Reflex) — from openload_front/

Option 3: Docker Databases + Local Code

Development Requirements

Runtime Versions

Reflex 0.9.0+ Compatibility

Architecture

Backend (Go) — Clean Architecture with DDD

Frontend (Python/Reflex) — Layered Modular Architecture

Data Flow

Core Features

🏗️ Projects & Services

🗄️ Prepare Data (Datasets)

📊 Analytics & Metrics

📈 Visualization

⚙️ Test Management

⏰ Scheduled Testing

🔀 Scenarios, Variable Extraction & Injection

🔌 WebSocket Protocol Support

📄 Pagination & Filtering

🔄 Comparative Analysis

Project Structure

Key Concepts

Roadmap

Completed

2026 Roadmap

Analysis & Debugging

Intelligence & Automation

Multi-Tenancy & Security

Contributing

Backend (Go)

Frontend (Python/Reflex)

Code Quality

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Backend (Go) — from `openload_back/`

Frontend (Python/Reflex) — from `openload_front/`

Packages