PHP is 5x Faster Than NestJS? Rethinking High-Load with Swoole.

Roman Shneer — Sat, 09 May 2026 13:05:29 +0000

For years, the industry consensus was clear: if you need high concurrency, non-blocking I/O, and microservices, you choose Node.js (NestJS) or Go. PHP was labeled as the "old-school" language, hindered by its "request-response" lifecycle and the overhead of booting the framework for every single hit.

I decided to challenge that stereotype.

I built a production-ready High-Load Event Processor capable of handling 10,000+ RPS using PHP 8.4 and Swoole. In my stress tests, this architecture consistently outperformed equivalent NestJS setups by nearly 5x in throughput, while maintaining a significantly lower latency floor.

The Problem with the Status Quo

Traditional PHP (FPM) is like a restaurant that hires and fires its entire staff every time a customer walks in. It’s reliable but inefficient for high-frequency event ingestion. Node.js improved this with a persistent event loop, but even the V8 engine has its limits when managing tens of thousands of concurrent Promises.

Why Swoole Changes Everything

Swoole isn't just a library; it’s a C-native coroutine engine that transforms PHP into a high-performance, persistent-memory powerhouse. Here is why it crushed the competition in my benchmarks:

1. C-Native Coroutines vs. The Event Loop
While NestJS relies on the JavaScript Event Loop and async/await overhead, Swoole introduces user-space threads (coroutines) managed at the C level. Context switching happens only during I/O operations, with far less CPU overhead than managing the Promise lifecycle in V8.

2. Persistent State & Zero Cold Starts
The application boots once. Database connections, configurations, and pre-compiled code stay in memory. This eliminates the "bootstrap tax" and allows for lightning-fast execution.

3. Native Connection Pooling
One of the biggest bottlenecks in high-load systems is the database. In my project, I implemented Swoole-native Connection Pooling for PostgreSQL and Redis. Unlike standard Node.js drivers that can struggle under extreme concurrency, Swoole handles thousands of active connections with minimal memory footprint.

The Architecture: 10,000 Requests Per Second

My system uses a multi-layered approach to ensure Zero Data Loss:

Ingestion: A Swoole HTTP server receives events and pushes them into a Redis buffer using non-blocking coroutines.
Buffering: Redis acts as a high-speed shock absorber for traffic spikes.
Processing: Dedicated workers pull batches from Redis and persist them to PostgreSQL using optimized write-pipelines.

The Results

Using Artillery for load testing, the results were undeniable:

Throughput: Stable 10k+ RPS on standard hardware.
Latency: p95 remained flat even as concurrency scaled.
Reliability: 0% packet loss, thanks to the asynchronous pipeline.

Conclusion: Is PHP Back?

PHP never left, but it has evolved. With Swoole, we no longer have to trade the rapid development cycle of PHP for the performance of Go or Node.js. We can have both.

If you are building microservices in 2026 and performance is your priority, it’s time to stop looking at PHP in the rearview mirror and start looking at what it can do with Swoole.

PHP stress test

artillery run performance/main.yml

NestJS stress test

artillery run performance/main.yml

PHP/Swoole Insert 1million records

artillery run performance/insert1m.yml

NestJs Insert 1 million records

artillery run performance/insert1m.yml

🔗 Check out the full source code and benchmarks on my GitHub:

PHP/Swoole: https://github.com/roman-shneer/high-load-event-processor-php

NestJS: https://github.com/roman-shneer/high-load-event-processor

Laravel Application with Encrypted .env

Roman Shneer — Wed, 29 Apr 2026 06:06:50 +0000

This guide explains how to securely run a Laravel application (version 12) in a production environment using Apache, with an encrypted .env file.

Overview

In production, it’s crucial to protect sensitive information found in the .env file. This method encrypts your configuration file and utilizes an encryption key stored in an environment variable for security.

Steps to Run Laravel with Encrypted .env

Step 1: Encrypt the .env File

Execute the following command in your terminal to prepare the encoded file:

php artisan env:encrypt

Note: Remember your encryption key and cipher settings as you'll need them later.

Step 2: Set Environment Variable in Apache

Open your httpd.conf (or .htaccess) file and add the following line to set the encryption key:

SetEnv LARAVEL_ENV_ENCRYPTION_KEY your_key_here

Afterwards, restart your web server:

sudo systemctl restart apache2

Step 3: Decrypt the .env File in Laravel

Add the following code snippet in /bootstrap/app.php before the line where the application is configured:
Application::configure(....

//START ENV DECODING

use Illuminate\Encryption\Encrypter;
use Illuminate\Support\Str;
$cipher = 'aes-256-cbc'; //change your cipher
$filename = '.env.encrypted';//change your encrypted file

$key = getenv('LARAVEL_ENV_ENCRYPTION_KEY'); // Retrieve the encryption key from the environment variables

$encryptedContent = file_get_contents("../{$filename}");
if (Str::startsWith($key, $prefix = 'base64:')) {
    $key = base64_decode(Str::after($key, $prefix));
}

$decrypted_text = (new Encrypter($key, $cipher))
    ->decrypt($encryptedContent);

$rows = array_filter(
    explode("\n", $decrypted_text),
    fn($r) => !empty(trim($r))
);

$rows = array_map(
    fn($r) => array_map(
        fn($r) => trim(
            str_replace('"', '', $r)
        ),
        explode("=", $r)
    ),
    $rows
);

foreach ($rows as $row) {
    $_SERVER[$row[0]] = $row[1];
}

//END ENV DECODING

Step 4: Final Cleanup

By following these steps, you can run your Laravel application securely with an encrypted .env file. Ensure you keep your encryption key safe to maintain the integrity of your sensitive information.

Backup and Delete the Original .env File

Forem: Roman Shneer