PHP vs NodeJS Comparison and Benchmark

Almost every day there are some new technologies emerging, that are trying to change the web landscape. Server-side of the web development also is divided, there are long-standing heavy-weights such as Java, C, and Perl and newer, more web-focused languages like Ruby, Clojure and Go. But how to select a perfect solution for your project? We will compare two back-end technologies PHP vs NodeJS. We hope we won’t start a holy war.

First of all, let’s define PHP and Node.js.


PHP is a server-side scripting language. It was created in 1994 by Rasmus Lerdorf in 1994 primarily for web development. Originally PHP stood for Personal Home Page, but now it stands for a recursive acronym – PHP: Hypertext Preprocessor.  
Usually, PHP is processed by an interpreter, powered by the Zend Engine, that is installed on web servers such as Apache and Nginx. Also PHP code can be embedded into HTML or HTML5 markup. This flexibility contributed to the popularity of the language, PHP is now used on more than 80% of web servers.


Node.js is an open-source, JavaScript run-time environment used to execute JavaScript code on the server-side. Node.js development process has changed the paradigm that JavaScript is used primarily on the client-side. That’s why Node.js has become one of the foundational elements of the “JavaScript everywhere” paradigm. Node.js was created by Ryan Dahl in 2009. It is powered by Google’s V8 JS engine, that is the same engine that is used in Google Chrome web browser. This JS runtime environment doesn’t need a separate web server or other dependencies, there are built-in libraries that take care of that. Compared to PHP, Node.js is relatively young, however, it is already well recognized and used by giant companies like Microsoft, Yahoo, LinkedIn, and PayPal.

For a clearer view, here is the PHP vs NodeJS comparison of the popularity indicators in the form of a table: 

Release date08.06.199527.05.2009
Package’s repository (Dependency Manager)ComposerNPM
Have LTS?++
License (Free for commercial use)PHP LicenseMIT License
Vacancies/ Developers~100 000/400000060000/*
Packages  on packagist/ npm152 453~450,000
Open-source projects290,757114,353
Questions on stackoverflow1,112,866187,917
GitHub stars12 67038 398
Most popular conferences of 2016Laracon EU 2016
SymfonyCon Berlin 2016
Ski PHP Conference 2016
PHPBenelux Conference 2016
SunshinePHP 2016
The PHP UK Conference
Symfony official certification
Node.js Certification Program

Features and Benefits of PHP and NodeJS

Benefits of PHP

Some developers say that PHP is much easier to use then Node.js. Their arguments are:

  • It’s easier to configure the development environment for PHP
  • Node.js requires more code
  • In order to code on Node.js, you have to understand callback functions and blockings
  • All internet hosting services support PHP
  • Supports more frameworks and CMS
  • Official code organization recommendations (PSR)
  • PHP has a larger library of instructions and frequently asked questions (there were plenty in 20 years)
  • The PHP developers community is a massive and diverse group of people, they are constantly re-visioning and updating libraries, frameworks and other PHP components

You should consider using PHP when your project includes:

  • CMS technologies such as WordPress, Drupal, Joomla, etc, even if there is only a part of your project includes these technologies (for example blog, admin page, online store etc.)
  • If you are using a relational database – go with PHP.

To sum up the whole server side of this PHP vs NodeJS comparison, PHP supports following database management systems:


  • MySQL
  • MySQLi
  • SQLite
  • PostgreSQL
  • Oracle(OCI8)
  • Oracle
  • Microsoft SQL Server
  • Sybase
  • ODBC
  • mSQL
  • IBM DB2
  • Cloudspace
  • Apache Derby
  • Informix


  • Ovrimos SQL
  • Lotus Notes
  • DB++
  • DBM
  • dBase
  • DBX
  • FrontBase
  • filePro
  • Ingres II
  • Firebird/InterBase
  • Paradox File Access
  • MaxDB
  • PDO

Benefits of Node.JS

One of the main advantages of NodeJS is the support of multithreading. While it is a necessity in browsers, it is not that much needed in web development process.

“The scripting language does not need to be threaded”

Rasmus Lerdorf

A lot of developers choose Node.js over PHP. Here’s why:

  • Built-in server support
  • A single syntax for client and server side of the website. This improves the reusability of the code and makes the work of a full stack developer easier
  • Module caching – modules are downloaded and initialized when they are called for the first time, afterward they are constantly available
  • Stream module makes it easier to work with large files
  • Node has an almost identical syntax to JavaScript, thus it easy to pick-up and learn for JS developers.

Chrome V8 engine

As it was stated before, Node.js is powered by Chrome V8 engine. This engine is the source of many other benefits. You should consider using Node.JS when your project includes:

  • Streaming data transfer – traditional web stacks usually convert queries and corresponding HTTP to elementary events. However, they are data streams, and Node.js apps can take advantage of that. A great example of this kind of data stream is file processing during the download or data transfer between different layers.  
  • NodeJS supports real-time Web development – this allows to develop chats, betting apps, apps like Twitter, or interfaces for instant messaging with ease. But you have to be careful with that. Because the response time can vary, if the garbage collector interferes, he stops the execution of the program. So, don’t try to develop an app or a system with a guaranteed response time on NodeJS. Erlang is a way better choice for this job.
  • Software packages that include NodeJS, for example, MEAN (mongoDB, Express.js, Angular.js, Node.js)
  • Built-in expansion capabilities (cluster package)

Here is the PHP vs NodeJS comparison table of supported technologies:


CMSMagento, WordPress, Opencart, Drupal, Joomla, PrestaShopApostrophe2, Ghost, KeystoneJS, enduro.js, Pencilblue
MVC frameworksSymfony, Laravel, Yii, Codeigniter, Zend, Phalcon, CackePHPKoa JS, Express JS, Sails JS
RealtimeRatchet, Wrench,, Socket.iows, Sockjs,
REST API RestClient, Guzzle, HTTPFULRestify, Loopback
Scaffoldingsymfony+, laravel+ , yii+, CackePHPYeoman
HTML templatingTwig
Embedded js
Horizontal scaling implementationElastic beanstalk, varnishCluster mode, Amazon Elastic Beanstalk
Load balancer support++
Multiple drivers support DB, storage++
Full-text search++
ProfilingXdebug, Blackfire, XHProf, XHGuiBuilt in profiler
CachingRedis, MemcacheRedis, Memcache
CI supportTravis CI, CodeshipTravis CI, Codeship
Cucumber (behat)


It is a good idea to choose a winner in PHP vs Node.js based on the features and benefits. However, it is always better to see how they are performing back to back, PHP vs NodeJS. We have created two different test cases and will run them on the same machine.

The test bench configuration:

  • VDS
  • CPU – 1 core, 2GHz
  • RAM – 1GB RAM
  • Storage – 10GB SSD
  • OS – Debian 8.6
  • PHP 7.0.22 FPM
  • Node.js 6.11.2

PHP vs NodeJS – First test

This test will show us how well PHP and Node.js are working with arrays,  string concatenation, network I/O, and arithmetics.

NodeJS source code:

var fs = require('fs');
var mysql = require('mysql2');

console.time('Node.js ' + process.version + ': concatenations of strings 1000000 times');
var str = '';
for (var i = 0; i < 1000000; i++) {
 str += 's';
console.timeEnd('Node.js ' + process.version + ': concatenations of strings 1000000 times');

console.time('Node.js ' + process.version + ': adding numbers 1000000 times');
var count = 0;
for (var i = 0; i < 1000000; i++) {
console.timeEnd('Node.js ' + process.version + ': adding numbers 1000000 times');

console.time('Node.js ' + process.version + ': filling of array 1000000 times');
var array = [];
for (var i = 0; i < 1000000; i++) {
console.timeEnd('Node.js ' + process.version + ': filling of array 1000000 times');

console.time('Node.js ' + process.version + ': filling of associative array 1000000 times');
var array = {};
for (var i = 0; i < 1000000; i++) {
 array['s' + i] = 's';
console.timeEnd('Node.js ' + process.version + ': filling of associative array 1000000 times');

console.time('Node.js ' + process.version + ': reading the file 100 times');
var content;
for (var i = 0; i < 100; i++) {
    content = fs.readFileSync('./someFile.txt');
console.timeEnd('Node.js ' + process.version + ': reading the file 100 times');

console.time('Node.js ' + process.version + ': mysql query (SELECT NOW()) 100 times');
// create the connection to database
var connection = mysql.createConnection({host:'localhost', user: 'root', database: 'test', password: 'password'});

function promiseQuery(query) {
    return new Promise((resolve, reject) => {
            connection.query(query, function (err, results, fields) {
            resolve({err, results, fields});
for (var i = 0; i < 100; i++) {
    var a = promiseQuery('SELECT NOW()');
    a.then(({err, results, fields}) => {
console.timeEnd('Node.js ' + process.version + ': mysql query (SELECT NOW()) 100 times');



PHP source code:

$phpVersion = "v" . explode('-', PHP_VERSION)[0];

$start = microtime(1);
$str = '';
for ($i = 0; $i < 1000000; $i++) {
 $str .= 's';

echo "PHP $phpVersion: concatenations of strings 1000000 times: " . round((microtime(1) - $start) * 1000, 3) . "ms \n";

$start = microtime(1);
$count = 0;
for ($i = 0; $i < 1000000; $i++) {

echo "PHP $phpVersion: adding of numbers 1000000 times: " . round((microtime(1) - $start) * 1000, 3) . "ms \n";
$start = microtime(1);
$array = array();
for ($i = 0; $i < 1000000; $i++) {
 $array[] = 's';

echo "PHP $phpVersion: filling of array 1000000 times: " . round((microtime(1) - $start) * 1000, 3) . "ms \n";

$start = microtime(1);
$array = array();
for ($i = 0; $i < 1000000; $i++) {
 $array["s" . $i] = 's';

echo "PHP $phpVersion: filling of associative array 1000000 times: " . round((microtime(1) - $start) * 1000, 3) . "ms \n";

$start = microtime(1);
for ($i = 0; $i < 100; $i++) {
    $fp = fopen("./someFile.txt", "r");
    $content = fread($fp, filesize("./someFile.txt"));

echo "PHP $phpVersion: reading the file 100 times: " . round((microtime(1) - $start) * 1000, 3) . "ms \n";

$start = microtime(1);
$mysql = new mysqli('localhost', 'root', 'password', 'test');
for ($i = 0; $i < 100; $i++) {
 $res = $mysql->query("SELECT NOW() as `now`");
 $now = $res->fetch_assoc()['now'];

echo "PHP $phpVersion: mysql query (SELECT NOW()) 100 times: " . round((microtime(1) - $start) * 1000, 3) . "ms \n";

The results:

php vs nodejs first test php

php vs nodejs first test nodejs
As you can see PHP is faster than Node.js in:

  • Concatenation of strings
  • Filling array
  • Filling associative array
  • Reading the file
  • MySQL query

Node.js is faster than PHP only in adding numbers.

PHP vs NodeJS  – Second test

Now, we will test out how well Node.js and PHP are handling multi threaded tasks. We will throw at them 1000 queries in 1000 threads. Don’t look too hard into the source code, all configuration was done on the server side.

Nginx 11.7 + PHP 7.1.1 FPM vs Node.js

PHP source code:

echo "Hello world";



Node.js source code:

const http = require('http');

const hostname = '';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World');

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);





The results:

php vs nodejs second test nodejs

php vs nodejs second test php

The second test has ended and the results are in favor of PHP, again. The numbers are:

  • PHP + Nginx – 32 ms
  • NodeJS – 200 ms

To put this numbers into a somewhat more acceptable form, PHP is capable to process 31,250 queries per second, Node.js, on the other hand, can deal with 5,000 queries per second.

0 0 vote
Article Rating
Share this: