Discover the unparalleled power and affordability of LoadForge, one of the world’s highest-capacity load test solutions.

​
Key Features

  • Scalability: Achieve over 5 million SSL transactions per second (TPS) and beyond.
  • Duration: Run tests continuously for several days if required.
  • Affordability: Test at capacities that were previously either out of reach or prohibitively expensive.

​
The Technology Behind the Power

​
How Do We Achieve Such Scale?

LoadForge is a cloud-native solution, designed to dynamically scale up with test demand. It launches dedicated cloud test servers to generate massive load.

With 40 worker servers available per test, each capable of generating 10,000 to 40,000 virtual users (VUs), LoadForge delivers unparalleled flexibility and performance.

​
Example: Targeting 400,000 SSL Users per Second

  1. Deploy 40 worker servers.
  2. Assign 10,000 users per server (scalable up to 40,000 per server).
  3. This results in 400,000+ concurrent users, generating nearly 800,000 requests per second.

To scale further, launch multiple tests across global data centers (London, San Francisco, Singapore, New York, etc.):

  • 800,000 requests/second per test × 4 locations = 3,200,000 SSL TPS.

​
Affordability: High Performance at a Fraction of the Cost

LoadForge leverages public cloud infrastructures, ensuring cost-effective large-scale testing. Example pricing:

  • Each test server costs $0.24 per test per hour.
  • Running a 3.2 million SSL TPS test with 40 servers costs approximately $19.20 per hour.

​
Designing High Load Tests: An Overview

High-scale tests focus on individual system components, such as:

  • Web servers (Nginx, Apache, etc.)
  • Load balancers (AWS ALB, HAProxy, etc.)
  • Caches (Redis, Memcached, etc.)
  • CDNs (Cloudflare, Akamai, etc.)

We recommend isolating components for focused testing, but you have full flexibility to design your test strategy.

​
Using FastHttpUser for Maximum Performance

For very high-performance testing, we recommend using FastHttpUser instead of the standard HttpUser.

​
Why Use FastHttpUser?

  • Reduces Overhead: Standard HttpUser uses requests, which is slower compared to fasthttp.
  • Optimized for Throughput: It uses a more efficient HTTP client, significantly increasing the number of requests per second.
  • Essential for Large-Scale Tests: If you are targeting millions of transactions per second, FastHttpUser is mandatory.

​
Converting a Standard Locust Script to FastHttpUser

A typical HttpUser test:

from locust import HttpUser, task, between

class MyUser(HttpUser):
    wait_time = between(5, 9)

    @task
    def index(self):
        self.client.get("/")

To convert this for maximum performance, simply replace HttpUser with FastHttpUser:

from locust import task, between
from locust.contrib.fasthttp import FastHttpUser

class MyUser(FastHttpUser):
    @task
    def index(self):
        self.client.get("/")

This modification alone can double or quadruple the number of requests each worker can handle, increasing efficiency while reducing costs.

​
Engage with Our Experts

Tests of this magnitude require either our Enterprise or Premium packages:

  • Enterprise Package: Supports large-scale testing (up to 4 million TPS and beyond).
  • Premium Package: Allows testing with up to 150,000 users.

Both packages include dedicated support for test design and scaling guidance. Contact our team to discuss your specific requirements and optimize your load testing strategy.

SSL VerificationRun Results