DEV Community: Islam A-Elwafa

PHP Stress Testing Tool: How to Stress Test PHP & Laravel Apps

Islam A-Elwafa — Mon, 15 Jun 2026 07:54:27 +0000

How to Stress Test PHP and Laravel Applications

Choosing a PHP stress test tool usually means a painful trade-off: the popular load testing tools all live outside PHP, so you end up writing scenarios in JavaScript, Java, or XML instead of the language your app is built in. This guide takes a different approach. We'll cover what stress testing actually means for a PHP application, what to look for in a tool, how the main options compare, and how to run your first stress test on plain PHP or Laravel in just a few minutes — without leaving your Composer workflow.

What Is Stress Testing in PHP?

Stress testing pushes your application beyond its normal operating limits to find the point where it breaks — and to see how it breaks. It answers questions a single request never can: How many concurrent users can your API handle before response times spike? Does the database connection pool exhaust under load? Does the app fail gracefully or fall over?

It's easy to confuse the different flavors of performance testing:

Load testing — verify the app handles an expected level of traffic.
Stress testing — push past expected traffic to find the breaking point.
Spike testing — slam the app with a sudden surge of users.

They overlap heavily and most tools (including VoltTest) handle all three. For a full breakdown of each type, see Performance Testing Types. For the rest of this article we'll use "stress testing" loosely to mean putting your PHP app under realistic concurrent load.

What to Look For in a PHP Stress Testing Tool

Not every load testing tool fits a PHP team. Before picking one, check it against these criteria:

PHP- and Composer-native — can you write tests in PHP and install via Composer, or do you have to learn a separate language and toolchain?
Realistic multi-step scenarios — real users log in, browse, add to cart, and check out. The tool should chain requests and pass data (tokens, IDs, CSRF) between steps.
Ramp-up and stages — instantly hitting your app with 1,000 users isn't realistic. You want ramp-up, hold, spike, and ramp-down profiles.
Percentile metrics — averages hide problems. You need P95 and P99 latency, requests per second, and success/error rates.
CI/CD integration — stress tests are most valuable when they run automatically and catch regressions before they ship.
Assertions — the ability to fail a build when, say, P95 exceeds 150ms.
Scale — can it generate enough concurrent virtual users to actually stress your infrastructure?

The first point is where most tools fall short for PHP developers — and where the comparison below gets interesting.

PHP Stress Testing Tools Compared

Here's an honest look at the most common options for stress testing a PHP application:

Tool	Write tests in	PHP-native	Laravel-native	Multi-step scenarios	Best for
VoltTest	PHP	Yes	Yes	Yes	PHP/Laravel teams who want native tests on a fast engine
k6	JavaScript	No	No	Yes	JS-heavy teams comfortable scripting in JS
JMeter	XML / GUI	No	No	Yes	Protocol breadth and complex enterprise plans
Locust	Python	No	No	Yes	Python teams
Apache Bench (`ab`)	CLI flags	No	No	No	Quick one-off single-endpoint checks

There's no single "best" tool — it depends on your stack:

k6 is excellent if your team already lives in JavaScript.
JMeter is the veteran for protocol breadth and large enterprise test plans, at the cost of a heavier, GUI-driven workflow.
Apache Bench is perfect for a quick ab -n 1000 -c 50 sanity check on a single URL, but can't model real user journeys.
VoltTest is built specifically for PHP and Laravel developers: you write tests in PHP, install with Composer, and a Go engine handles the actual load generation — so you get PHP's ergonomics with Go's concurrency. It's the only option here with a first-party Laravel package — and on Laravel it gives you the same one-line speed as ab (php artisan volttest:run <url>) and full multi-step scenarios when you need them.

The next sections show exactly how that works — from a stress test in plain PHP, to a full Laravel scenario, to a one-line CLI test you can fire off like ab.

Stress Testing Plain PHP with VoltTest

VoltTest's core SDK is framework-agnostic — it works with any PHP application, whether that's Symfony, WordPress, or raw PHP. Install it with Composer:

composer require volt-test/php-sdk

Then define a scenario and run it. Here's a minimal stress test that hits your homepage:

<?php
require 'vendor/autoload.php';

use VoltTest\VoltTest;

// Create a new test
$voltTest = new VoltTest('Homepage Stress Test');

// Configure the load: 50 virtual users, ramped up over 10s, held for 1 minute
$voltTest->setVirtualUsers(50)
    ->setRampUp('10s')
    ->setDuration('1m');

// Define a scenario with one or more steps
$scenario = $voltTest->scenario('Browse Homepage');
$scenario->step('Load homepage')
    ->get('https://your-app.test/')
    ->validateStatus('Homepage OK', 200);

// Run the test — passing true streams the live report to your console
$voltTest->run(true);

Run it like any PHP script:

php stress-test.php

Because the heavy lifting happens in VoltTest's Go engine, a single machine can drive far more concurrent virtual users than a pure-PHP runner could — while you keep writing tests in the language you already use.

Stress Testing a Laravel Application

If you're on Laravel, the dedicated package builds on the core SDK and adds Laravel-specific conveniences: Artisan commands, automatic route discovery, and CSRF/cookie handling. Install it as a dev dependency:

composer require volt-test/laravel-performance-testing --dev
php artisan vendor:publish --tag=volttest-config

Scaffold a test with Artisan:

php artisan volttest:make LoginTest

Then define the scenario. Note extractCsrfToken() — the package pulls Laravel's CSRF token out of the response automatically, so you don't have to:

<?php

namespace App\VoltTests;

use VoltTest\Laravel\Contracts\VoltTestCase;
use VoltTest\Laravel\VoltTestManager;

class LoginTest implements VoltTestCase
{
    public function define(VoltTestManager $manager): void
    {
        $manager->target('http://localhost:8000');

        $scenario = $manager->scenario('Login Flow');

        $scenario->step('Get Login Page')
            ->get('/login')
            ->expectStatus(200)
            ->extractCsrfToken();

        $scenario->step('Submit Login')
            ->post('/login', [
                'email' => 'user@example.com',
                'password' => 'password',
                '_token' => '${csrf_token}',
            ])
            ->expectStatus(302);
    }
}

The Laravel package also supports stages (ramp-up, hold, spike, ramp-down), CSV data sources for driving tests with realistic data, and a PHPUnit integration so your stress tests run inside your existing test suite with assertions like assertVTP95ResponseTime().

Two existing guides cover the Laravel workflow in depth:

Stress Testing Laravel Applications with VoltTest (Web UI Flow) — a full registration-to-dashboard scenario.
Load Testing Laravel Applications with PHPUnit and Volt-Test — run performance assertions inside PHPUnit and catch regressions in CI.

Quick One-Off Stress Tests from the Command Line

Sometimes you don't want to write a test class at all — you just want to hammer one endpoint and see if it holds up, the way you would with ab -n 1000 -c 50. The Laravel package's volttest:run command does exactly that, with none of ab's limitations.

Stress test a single URL with 50 virtual users for one minute — the command auto-detects that the argument is a URL, so there's nothing else to configure:

php artisan volttest:run https://api.example.com/health --users=50 --duration=1m

You can also stress test authenticated POST endpoints with a request body inline:

php artisan volttest:run https://example.com/api/login \
    --users=100 \
    --method=POST \
    --body='{"email":"test@example.com","password":"secret"}'

Useful flags (run php artisan volttest:run --help for the full list):

Flag	Purpose
`--users=`	Number of virtual users
`--duration=`	How long to run (e.g. `30s`, `1m`, `5m`)
`--method=`	HTTP method — `GET`, `POST`, `PUT`, `DELETE`
`--body=`	Request body for `POST`/`PUT`
`--headers=`	JSON string of request headers
`--code-status=`	Expected HTTP status code (default `200`)
`--stage=`	Load stages as `duration:target`, e.g. `--stage=1m:50 --stage=5m:100 --stage=1m:0`
`--cloud`	Run the test on VoltTest Cloud
`--stream`	Stream live output to the console

This gives you the one-liner speed of Apache Bench but with real virtual-user behavior, percentile metrics, ramp-up stages, and a path to cloud-scale execution — all from a single Artisan command.

Reading Your Stress Test Results

A stress test is only useful if you can interpret the report. VoltTest output looks like this:

Performance Report: Homepage Stress Test
----------------------------------------------------------------------
Total Requests:      5000
Success Rate:        99.94%
Requests/Sec (RPS):  346.19
Avg Latency:         74.24ms
P95 Latency:         128.71ms
P99 Latency:         210.05ms
----------------------------------------------------------------------

What to focus on:

Success Rate — anything below ~99% under load usually means the app is dropping requests or erroring out.
Requests/Sec (RPS) — your real-world throughput ceiling.
Avg Latency — useful, but it hides outliers. Don't ship on the average alone.
P95 / P99 Latency — the latency 95% and 99% of users experience. This is where real problems surface: an average of 74ms with a P99 of 2,000ms means 1 in 100 users is having a terrible time.

When you stress test, watch how P95 and P99 climb as you add virtual users. The point where they spike sharply is your breaking point.

Common PHP Stress Testing Mistakes

A few mistakes make stress test results misleading:

Testing localhost — your laptop is not production. Network, CPU, and database differ wildly. Test against a staging environment that mirrors production.
No ramp-up — slamming the app with all users at once measures a thundering herd, not real traffic. Use stages to ramp up gradually.
Ignoring P99 — averages look fine while a slice of users suffer. Always read the tail latencies.
Stress testing production unannounced — you can take down a live system. Coordinate with your team, and prefer staging or a clearly-marked maintenance window.

Run Large-Scale Stress Tests with VoltTest Cloud

Running stress tests from one machine works well up to a point. To simulate hundreds of thousands of concurrent users from multiple regions, you need distributed infrastructure — and that's what VoltTest Cloud provides, without you managing a single server.

Conclusion

Stress testing tells you how your PHP application behaves under pressure before your users find out the hard way. The right tool removes the friction: with VoltTest you write tests in PHP, install via Composer, run them against plain PHP or Laravel, and read real percentile metrics — all on a high-performance Go engine. Start small with a single scenario on staging, watch your P95 and P99 as load climbs, and wire the tests into CI so regressions never reach production.

⭐ Star the repository on GitHub: volt-test/php-sdk

💬 Follow updates on X: @VoltTest

Effortless Laravel Performance Testing — Without Leaving PHP

Islam A-Elwafa — Thu, 14 Aug 2025 13:25:21 +0000

When your Laravel app hits real traffic, will it fly… or will it fall over?

Most load-testing tools make you jump through hoops — learn a new scripting language, spin up external services, or fight with configs that feel like they belong to another ecosystem.

That’s why I built the Laravel Performance Testing package:

a native, PHP-first way to run load and stress tests right inside your Laravel project — powered by the Volt Test PHP SDK.

You write your tests in plain PHP, keep them version-controlled with your codebase, and run them with a single Artisan command. No context-switching. No external scripts. Just Laravel, PHP, and the performance insights you need before your users find the bottlenecks.

Why I Created This Package

About a month ago, I released this package to make performance testing in Laravel:

Easier – no external scripts or frameworks to learn.
Native – tests live inside your Laravel project.
Flexible – from simple single-URL load tests to complex multi-step scenarios.

✨ Features

Laravel-friendly integration – Works seamlessly with routes, middleware, and config.
Artisan commands – Generate and run tests directly from the CLI.
Automatic route discovery – Quickly build test scenarios from your existing routes.
Variable extraction – Reuse cookies, headers, JSON fields, and HTML values between steps.
Data-driven testing – Feed test data from CSV files for realistic simulations.
Detailed metrics – Success rate, RPS, average latency, P95 latency, and more.
Report storage – Save test results for later analysis.

🚀 Installation

composer require volt-test/laravel-performance-testing

Publish the configuration file:

php artisan vendor:publish --tag=volttest-config

This creates config/volttest.php where you can tweak settings like default virtual users, duration, and report paths.

⚡ Quick Start

Run a quick performance test without writing any code:

php artisan volttest:run https://example.com/api/login --users=100 --method=POST --body='{"email":"test@example.com","password":"secret"}'

Or, create a reusable test class:

php artisan volttest:make ExampleTest

This generates app/VoltTests/ExampleTest.php:

namespace App\VoltTests;

use VoltTest\Laravel\Contracts\VoltTestCase;
use VoltTest\Laravel\VoltTestManager;

class ExampleTest implements VoltTestCase
{
    public function define(VoltTestManager $manager): void
    {
        $manager->scenario('ExampleTest')
            ->step('Visit Home Page')
            ->get('https://example.com')
            ->validateStatus('success', 200);
    }
}

Run it with:

php artisan volttest:run ExampleTest --users=50 --duration=30

🎯 Route-Based Test Generation

Skip manual coding by generating tests from your Laravel routes:

# Include all routes
php artisan volttest:make ApiTest --routes

# Filter by pattern
php artisan volttest:make ApiTest --routes --filter="api/*"

# Only GET routes
php artisan volttest:make ApiTest --routes --method=GET

# Only authenticated routes
php artisan volttest:make ApiTest --routes --auth

# Interactive selection
php artisan volttest:make ApiTest --routes --select

📊 Data-Driven Testing

Simulate realistic usage with CSV files.

users.csv

name,email,password
John Doe,user1@example.com,password123
Jane Smith,user2@example.com,password456

Test definition:

$manager->scenario('RegisterTest')
    ->dataSource('users.csv')
    ->step('Register User')
    ->post('/register', [
        'name' => '${name}',
        'email' => '${email}',
        'password' => '${password}',
    ]);

🔍 Extract & Reuse Values

CSRF token from HTML

$scenario->step('Get Login Page')
    ->get('/login')
    ->extractCsrfToken('csrf_token');

$scenario->step('Submit Login')
    ->post('/login', [
        '_token' => '${csrf_token}',
        'email'  => 'user@example.com',
        'password' => 'secret',
    ]);

JSON field

$scenario->step('Get User')
    ->get('/api/user')
    ->extractJson('user_id', 'data.id');

Header

$scenario->step('Get Token')
    ->get('/auth')
    ->extractHeader('Authorization', 'Bearer ${token}');

📈 Analyzing Results

After running a test, you’ll see metrics such as:

✅ Success rate
⚡ Requests per second (RPS)
⏱ Average & P95 latency
⌛ Duration
❌ Errors

If save_reports is enabled, detailed reports are stored in:

storage/volttest/reports

🏁 Conclusion

With Laravel Performance Testing powered by the Volt Test PHP SDK, you can:

Keep performance tests inside your Laravel project.
Run them with one Artisan command.
Get actionable performance metrics before your users notice slowdowns.

📚 Docs: Laravel Performance Testing on GitHub

📦 Volt Test PHP SDK: php.volt-test.com

💡 Pro Tip: Integrate Volt-Test into your CI pipeline to catch performance regressions before they hit production.

Stress Testing Laravel Applications with VoltTest (Web UI Flow)

Islam A-Elwafa — Fri, 25 Jul 2025 19:46:36 +0000

Introduction

In this tutorial, we will explore how to perform stress testing on a Laravel application using the VoltTest PHP SDK. You will learn how to:

Simulate multiple users interacting with your Laravel application.
Test user registration and authentication workflows.
Measure application performance under load.
Extract dynamic values like CSRF tokens during test execution.
Use a CSV file as a data source for testing.
Analyze and optimize performance bottlenecks.

By the end of this guide, you will be able to confidently run automated performance tests to ensure your Laravel app is scalable and resilient.

Prerequisites

Ensure you have the following:

A running Laravel application
PHP 8.0 or higher
Composer installed

Installing VoltTest PHP SDK

First, install the VoltTest PHP SDK via Composer in your Laravel project:

composer require volt-test/php-sdk

Or clone the repository:

git clone https://github.com/volt-test/php-sdk.git
cd php-sdk
composer install

For Windows users, Visit the installation guide here

Creating Test Data

For a realistic test, create a CSV file (users.csv) with test user data:

email,password
user1@example.com,password123
user2@example.com,password123
user3@example.com,password123
user4@example.com,password123
user5@example.com,password123

Place this file in your project directory.

Writing the Stress Test

Create a file named laravel_stress_test.php in your project root and add the following script (or you can use the laravel's command):

<?php

require 'vendor/autoload.php';

use VoltTest\DataSourceConfiguration;
use VoltTest\VoltTest;

// Define test
$test = new VoltTest(
'Laravel User Flow',
'Tests home page visit, user registration, and dashboard access'
);

// Configure test parameters
$test
->setVirtualUsers(5)
->setDuration('60s') // Optional: Set test duration
->setRampUp('10s') // Optional: Set ramp-up time
->setHttpDebug(true); // Enable HTTP debug logging for checking requests before sending the all requests

// Create test scenario
$userFlowScenario = $test->scenario('User Registration Flow')
->autoHandleCookies(); // Automatically handle cookies without extract them

// Set up data source
$userFlowScenario->setDataSourceConfiguration(
new DataSourceConfiguration(__Dir__ . '/users.csv', 'unique', true) // Load data from CSV file, should be the full path
);

// Step 1: Visit home page
$userFlowScenario->step('Visit Home Page')
->get('http://localhost:8000')
->header('Accept', 'text/html')
->validateStatus('home_page_loaded', 200)
->setThinkTime('2s');

// Step 2: Visit register page and extract CSRF token
$userFlowScenario->step('Visit Register Page')
->get('http://localhost:8000/register')
->header('Accept', 'text/html')
->extractFromHtml('csrf_token', 'input[name="_token"]', 'value')
->validateStatus('register_page_loaded', 200)
->setThinkTime('2s');

// Step 3: Submit registration form
$userFlowScenario->step('Submit Registration')
->post(
'http://localhost:8000/register',
'_token=${csrf_token}&name=Test User&email=${email}&password=${password}&password_confirmation=${password}'
)
->header('Content-Type', 'application/x-www-form-urlencoded')
->validateStatus('registration_successful', 302)
->setThinkTime('1s');

// Step 4: Access dashboard
$userFlowScenario->step('Visit Dashboard')
->get('http://localhost:8000/dashboard')
->header('Accept', 'text/html')
->validateStatus('dashboard_loaded', 200)
->setThinkTime('3s');

// Run test
$result = $test->run(true); // true enables real-time progress output

// Display results summary in case you turned off the real-time progress output
echo "\n\nTest Results Summary:\n";
echo "====================\n";
echo "Total Requests: " . $result->getTotalRequests() . "\n";
echo "Success Rate: " . $result->getSuccessRate() . "%\n";
echo "Requests/second: " . $result->getRequestsPerSecond() . "\n";
echo "Min Response Time: " . $result->getMinResponseTime() . "\n";
echo "Max Response Time: " . $result->getMaxResponseTime() . "\n";
echo "Avg Response Time: " . $result->getAvgResponseTime() . "\n";
echo "P95 Response Time: " . $result->getP95ResponseTime() . "\n";

Code Explanation

The stress test script simulates multiple users interacting with a Laravel web application. Here’s how it works:

Initialize VoltTest:

$test = new VoltTest(
'Laravel User Flow',
'Tests home page visit, user registration, and dashboard access'
);

- Creates a new test instance with a descriptive name.

Configure test parameters:

$test
->setVirtualUsers(5)
->setDuration('60s')
->setRampUp('10s')
->setHttpDebug(true);

5 virtual users: Simulate 5 concurrent users.
Running the test for 60 seconds: Optional - you can remove this line to run the test and finish when all virtual users finish their scenarios.
Ramping up over 10 seconds: Optional - you can remove this line to start all virtual users at the same time.
Enables HTTP debug logging: Optional - Inspect requests while sending them.

Create a test scenario:

$userFlowScenario = $test->scenario('User Registration Flow')
->autoHandleCookies();

Creates a scenario for user registration flow.
autoHandleCookies(): Automatically handles cookies without extracting them.

Set up data source:

$userFlowScenario->setDataSourceConfiguration(
new DataSourceConfiguration(__Dir__ . '/users.csv', 'unique', true)
);

Loads user data from users.csv file. To simulate different users for each virtual user.

Define test steps:

$userFlowScenario->step('Visit Home Page')
->get('http://localhost:8000')
->header('Accept', 'text/html')
->validateStatus('home_page_loaded', 200)
->setThinkTime('2s');

Visit Home Page: Sends a GET request to the home page.
Accept header: Optional - Specifies the expected response content type.
Validate Status: Optional - Checks if the response status is 200.
Think Time: Optional - Simulates user thinking time before the next step, so the virtual user will wait 2s before execute the next request.

Extract CSRF token from registration page:

$userFlowScenario->step('Visit Register Page')
->get('http://localhost:8000/register')
->header('Accept', 'text/html')
->extractFromHtml('csrf_token', 'input[name="_token"]', 'value')
->validateStatus('register_page_loaded', 200)
->setThinkTime('2s');

Visits the registration page.
Extracts the CSRF token from the HTML response. The token is stored in the variable ${csrf_token}.
- The way to extract the token is by using the extractFromHtml method, which takes the token name, the selector, and the attribute name.

Submit registration form:

$userFlowScenario->step('Submit Registration')
->post(
'http://localhost:8000/register',
'_token=${csrf_token}&name=Test User&email=${email}&password=${password}&password_confirmation=${password}'
)
->header('Content-Type', 'application/x-www-form-urlencoded')
->validateStatus('registration_successful', 302)
->setThinkTime('1s');

Submits the registration form with the extracted CSRF token and user data.
Validates the response status code.
Sets a 1-second think time before the next step.
The ${email} and ${password} variables are replaced with values from the CSV file.
The ${csrf_token} variable is replaced with the extracted CSRF token.
The validateStatus method checks if the response status is 302 (redirect).
The setThinkTime method simulates user thinking time before the next step.

Access dashboard:

$userFlowScenario->step('Visit Dashboard')
->get('http://localhost:8000/dashboard')
->header('Accept', 'text/html')
->validateStatus('dashboard_loaded', 200)
->setThinkTime('3s');

Ensures successful login by verifying dashboard access.

Run the test:

$result = $test->run(true);

Executes the test with real-time progress output.

Running the Test

Execute the script:

php laravel_stress_test.php

You'll see real-time progress, followed by a summary of test results.

Analyzing Results

Key Metrics:

Success Rate: Should be as close to 100% as possible
Response Times: Lower is better
Requests per Second: Higher means better scalability

Common Issues & Fixes

Low Success Rate

Possible Cause: Server overload
Solution: Reduce virtual users or optimize queries

High Response Times

Possible Cause: Database bottlenecks
Solution: Optimize queries, enable caching

CSRF Token Extraction Fails

Possible Cause: HTML structure changes
Solution: Update the selector

Next Steps

Expand tests to cover more user flows
Test with more virtual users
Automate stress tests in CI/CD pipelines

Conclusion

Using VoltTest for stress testing helps identify Laravel application bottlenecks before they impact users. Regular testing ensures scalability and reliability.

Stay tuned for our next guide on Stress Testing Laravel APIs with VoltTest!

Happy testing!

Get in Touch

For questions, discussions, or contributions, feel free to open an issue or start a discussion on the Volt-Test GitHub repository:
https://github.com/volt-test/php-sdk