Server Load Testing and FastCGI Microcaching for Traffic Peaks

Frequently Asked Questions About Server Performance and Microcaching

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Warm-up to 50 users
    { duration: '3m', target: 200 }, // Peak load: 200 concurrent users
    { duration: '1m', target: 0 },   // Cool-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<400'], // 95% of responses must be under 400ms
    http_req_failed: ['rate<0.01'],    // Error rate below 1%
  },
};

export default function () {
  // 1. Visit homepage
  let res1 = http.get('https://marketmenow.eu/');
  check(res1, { 'status is 200': (r) => r.status === 200 });
  sleep(1);

  // 2. Browse services section
  let res2 = http.get('https://marketmenow.eu/en/web-development/');
  check(res2, { 'services page loaded': (r) => r.status === 200 });
  sleep(2);
}

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Warm-up to 50 users
    { duration: '3m', target: 200 }, // Peak load: 200 concurrent users
    { duration: '1m', target: 0 },   // Cool-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<400'], // 95% of responses must be under 400ms
    http_req_failed: ['rate<0.01'],    // Error rate below 1%
  },
};

export default function () {
  // 1. Visit homepage
  let res1 = http.get('https://marketmenow.eu/');
  check(res1, { 'status is 200': (r) => r.status === 200 });
  sleep(1);

  // 2. Browse services section
  let res2 = http.get('https://marketmenow.eu/en/web-development/');
  check(res2, { 'services page loaded': (r) => r.status === 200 });
  sleep(2);
}

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

Simple pinging of a single page does not give a true picture of how the site will behave when real users search for products, add items to their carts, and browse categories. A load test must be a multi-step scenario. The k6 tool is ideally suited for this because it allows writing scenarios in modern JavaScript syntax.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Warm-up to 50 users
    { duration: '3m', target: 200 }, // Peak load: 200 concurrent users
    { duration: '1m', target: 0 },   // Cool-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<400'], // 95% of responses must be under 400ms
    http_req_failed: ['rate<0.01'],    // Error rate below 1%
  },
};

export default function () {
  // 1. Visit homepage
  let res1 = http.get('https://marketmenow.eu/');
  check(res1, { 'status is 200': (r) => r.status === 200 });
  sleep(1);

  // 2. Browse services section
  let res2 = http.get('https://marketmenow.eu/en/web-development/');
  check(res2, { 'services page loaded': (r) => r.status === 200 });
  sleep(2);
}

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

Simple pinging of a single page does not give a true picture of how the site will behave when real users search for products, add items to their carts, and browse categories. A load test must be a multi-step scenario. The k6 tool is ideally suited for this because it allows writing scenarios in modern JavaScript syntax.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Warm-up to 50 users
    { duration: '3m', target: 200 }, // Peak load: 200 concurrent users
    { duration: '1m', target: 0 },   // Cool-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<400'], // 95% of responses must be under 400ms
    http_req_failed: ['rate<0.01'],    // Error rate below 1%
  },
};

export default function () {
  // 1. Visit homepage
  let res1 = http.get('https://marketmenow.eu/');
  check(res1, { 'status is 200': (r) => r.status === 200 });
  sleep(1);

  // 2. Browse services section
  let res2 = http.get('https://marketmenow.eu/en/web-development/');
  check(res2, { 'services page loaded': (r) => r.status === 200 });
  sleep(2);
}

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

Step 1 - Creating a Realistic Load Test with k6

Simple pinging of a single page does not give a true picture of how the site will behave when real users search for products, add items to their carts, and browse categories. A load test must be a multi-step scenario. The k6 tool is ideally suited for this because it allows writing scenarios in modern JavaScript syntax.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Warm-up to 50 users
    { duration: '3m', target: 200 }, // Peak load: 200 concurrent users
    { duration: '1m', target: 0 },   // Cool-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<400'], // 95% of responses must be under 400ms
    http_req_failed: ['rate<0.01'],    // Error rate below 1%
  },
};

export default function () {
  // 1. Visit homepage
  let res1 = http.get('https://marketmenow.eu/');
  check(res1, { 'status is 200': (r) => r.status === 200 });
  sleep(1);

  // 2. Browse services section
  let res2 = http.get('https://marketmenow.eu/en/web-development/');
  check(res2, { 'services page loaded': (r) => r.status === 200 });
  sleep(2);
}

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

Step 1 - Creating a Realistic Load Test with k6

Simple pinging of a single page does not give a true picture of how the site will behave when real users search for products, add items to their carts, and browse categories. A load test must be a multi-step scenario. The k6 tool is ideally suited for this because it allows writing scenarios in modern JavaScript syntax.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Warm-up to 50 users
    { duration: '3m', target: 200 }, // Peak load: 200 concurrent users
    { duration: '1m', target: 0 },   // Cool-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<400'], // 95% of responses must be under 400ms
    http_req_failed: ['rate<0.01'],    // Error rate below 1%
  },
};

export default function () {
  // 1. Visit homepage
  let res1 = http.get('https://marketmenow.eu/');
  check(res1, { 'status is 200': (r) => r.status === 200 });
  sleep(1);

  // 2. Browse services section
  let res2 = http.get('https://marketmenow.eu/en/web-development/');
  check(res2, { 'services page loaded': (r) => r.status === 200 });
  sleep(2);
}

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

Many mistakenly believe that the solution is a more expensive server, but reliable server maintenance with Nginx architecture achieves stability through proper configuration. Yet in practice, even a 32-core server without a proper caching architecture will collapse under just 100 simultaneous dynamic PHP requests. In this technical guide, we will show you how to perform real load testing with open-source tools and implement Nginx FastCGI microcaching, allowing a regular virtual server to effortlessly handle thousands of requests per second.

Step 1 - Creating a Realistic Load Test with k6

Simple pinging of a single page does not give a true picture of how the site will behave when real users search for products, add items to their carts, and browse categories. A load test must be a multi-step scenario. The k6 tool is ideally suited for this because it allows writing scenarios in modern JavaScript syntax.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Warm-up to 50 users
    { duration: '3m', target: 200 }, // Peak load: 200 concurrent users
    { duration: '1m', target: 0 },   // Cool-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<400'], // 95% of responses must be under 400ms
    http_req_failed: ['rate<0.01'],    // Error rate below 1%
  },
};

export default function () {
  // 1. Visit homepage
  let res1 = http.get('https://marketmenow.eu/');
  check(res1, { 'status is 200': (r) => r.status === 200 });
  sleep(1);

  // 2. Browse services section
  let res2 = http.get('https://marketmenow.eu/en/web-development/');
  check(res2, { 'services page loaded': (r) => r.status === 200 });
  sleep(2);
}

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

Many mistakenly believe that the solution is a more expensive server, but reliable server maintenance with Nginx architecture achieves stability through proper configuration. Yet in practice, even a 32-core server without a proper caching architecture will collapse under just 100 simultaneous dynamic PHP requests. In this technical guide, we will show you how to perform real load testing with open-source tools and implement Nginx FastCGI microcaching, allowing a regular virtual server to effortlessly handle thousands of requests per second.

Step 1 - Creating a Realistic Load Test with k6

Simple pinging of a single page does not give a true picture of how the site will behave when real users search for products, add items to their carts, and browse categories. A load test must be a multi-step scenario. The k6 tool is ideally suited for this because it allows writing scenarios in modern JavaScript syntax.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Warm-up to 50 users
    { duration: '3m', target: 200 }, // Peak load: 200 concurrent users
    { duration: '1m', target: 0 },   // Cool-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<400'], // 95% of responses must be under 400ms
    http_req_failed: ['rate<0.01'],    // Error rate below 1%
  },
};

export default function () {
  // 1. Visit homepage
  let res1 = http.get('https://marketmenow.eu/');
  check(res1, { 'status is 200': (r) => r.status === 200 });
  sleep(1);

  // 2. Browse services section
  let res2 = http.get('https://marketmenow.eu/en/web-development/');
  check(res2, { 'services page loaded': (r) => r.status === 200 });
  sleep(2);
}

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

The biggest nightmare for any business owner is a situation where an expensive advertising campaign finally starts bringing in thousands of visitors, but the website becomes inaccessible after five minutes, displaying "504 Gateway Timeout" or "502 Bad Gateway" error messages. Every minute of downtime at that moment means hundreds or thousands of euros in lost revenue and permanently damaged customer trust.

Many mistakenly believe that the solution is a more expensive server, but reliable server maintenance with Nginx architecture achieves stability through proper configuration. Yet in practice, even a 32-core server without a proper caching architecture will collapse under just 100 simultaneous dynamic PHP requests. In this technical guide, we will show you how to perform real load testing with open-source tools and implement Nginx FastCGI microcaching, allowing a regular virtual server to effortlessly handle thousands of requests per second.

Step 1 - Creating a Realistic Load Test with k6

Simple pinging of a single page does not give a true picture of how the site will behave when real users search for products, add items to their carts, and browse categories. A load test must be a multi-step scenario. The k6 tool is ideally suited for this because it allows writing scenarios in modern JavaScript syntax.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Warm-up to 50 users
    { duration: '3m', target: 200 }, // Peak load: 200 concurrent users
    { duration: '1m', target: 0 },   // Cool-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<400'], // 95% of responses must be under 400ms
    http_req_failed: ['rate<0.01'],    // Error rate below 1%
  },
};

export default function () {
  // 1. Visit homepage
  let res1 = http.get('https://marketmenow.eu/');
  check(res1, { 'status is 200': (r) => r.status === 200 });
  sleep(1);

  // 2. Browse services section
  let res2 = http.get('https://marketmenow.eu/en/web-development/');
  check(res2, { 'services page loaded': (r) => r.status === 200 });
  sleep(2);
}

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

The biggest nightmare for any business owner is a situation where an expensive advertising campaign finally starts bringing in thousands of visitors, but the website becomes inaccessible after five minutes, displaying "504 Gateway Timeout" or "502 Bad Gateway" error messages. Every minute of downtime at that moment means hundreds or thousands of euros in lost revenue and permanently damaged customer trust.

Many mistakenly believe that the solution is a more expensive server, but reliable server maintenance with Nginx architecture achieves stability through proper configuration. Yet in practice, even a 32-core server without a proper caching architecture will collapse under just 100 simultaneous dynamic PHP requests. In this technical guide, we will show you how to perform real load testing with open-source tools and implement Nginx FastCGI microcaching, allowing a regular virtual server to effortlessly handle thousands of requests per second.

Step 1 - Creating a Realistic Load Test with k6

Simple pinging of a single page does not give a true picture of how the site will behave when real users search for products, add items to their carts, and browse categories. A load test must be a multi-step scenario. The k6 tool is ideally suited for this because it allows writing scenarios in modern JavaScript syntax.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Warm-up to 50 users
    { duration: '3m', target: 200 }, // Peak load: 200 concurrent users
    { duration: '1m', target: 0 },   // Cool-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<400'], // 95% of responses must be under 400ms
    http_req_failed: ['rate<0.01'],    // Error rate below 1%
  },
};

export default function () {
  // 1. Visit homepage
  let res1 = http.get('https://marketmenow.eu/');
  check(res1, { 'status is 200': (r) => r.status === 200 });
  sleep(1);

  // 2. Browse services section
  let res2 = http.get('https://marketmenow.eu/en/web-development/');
  check(res2, { 'services page loaded': (r) => r.status === 200 });
  sleep(2);
}

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching

The biggest nightmare for any business owner is a situation where an expensive advertising campaign finally starts bringing in thousands of visitors, but the website becomes inaccessible after five minutes, displaying "504 Gateway Timeout" or "502 Bad Gateway" error messages. Every minute of downtime at that moment means hundreds or thousands of euros in lost revenue and permanently damaged customer trust.

Many mistakenly believe that the solution is a more expensive server, but reliable server maintenance with Nginx architecture achieves stability through proper configuration. Yet in practice, even a 32-core server without a proper caching architecture will collapse under just 100 simultaneous dynamic PHP requests. In this technical guide, we will show you how to perform real load testing with open-source tools and implement Nginx FastCGI microcaching, allowing a regular virtual server to effortlessly handle thousands of requests per second.

Step 1 - Creating a Realistic Load Test with k6

Simple pinging of a single page does not give a true picture of how the site will behave when real users search for products, add items to their carts, and browse categories. A load test must be a multi-step scenario. The k6 tool is ideally suited for this because it allows writing scenarios in modern JavaScript syntax.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },  // Warm-up to 50 users
    { duration: '3m', target: 200 }, // Peak load: 200 concurrent users
    { duration: '1m', target: 0 },   // Cool-down
  ],
  thresholds: {
    http_req_duration: ['p(95)<400'], // 95% of responses must be under 400ms
    http_req_failed: ['rate<0.01'],    // Error rate below 1%
  },
};

export default function () {
  // 1. Visit homepage
  let res1 = http.get('https://marketmenow.eu/');
  check(res1, { 'status is 200': (r) => r.status === 200 });
  sleep(1);

  // 2. Browse services section
  let res2 = http.get('https://marketmenow.eu/en/web-development/');
  check(res2, { 'services page loaded': (r) => r.status === 200 });
  sleep(2);
}

When performing professional website speed optimization, this kind of load test precisely uncovers bottlenecks before a real marketing launch.

Aigars Armanovs Lead Technology & Marketing Architect

"Every dynamic WordPress page request requires 50 to 150 database queries and the interpretation of hundreds of PHP files. If you get 1,000 visitors in a single minute, that means 100,000 database queries. Nginx FastCGI microcaching stores a ready HTML response in RAM for 5 to 60 seconds. As a result, PHP and MySQL are not run needlessly at all, and the page response time drops from 800ms to 8ms."

Step 2 - Implementing Nginx FastCGI Microcaching

The secret of microcaching is a very short cache lifespan (for example, 10 seconds for static pages and blogs). This means content is always fresh for visitors, but during sudden traffic spikes, all 500 visitors receive the exact same pre-generated HTML file directly from Nginx memory.

# 1. Define cache path at the beginning of the Nginx configuration (outside the server block)
fastcgi_cache_path /var/run/nginx-cache levels=1:2 keys_zone=WORDPRESS:100m inactive=60m max_size=1g;
fastcgi_cache_key "$scheme$request_method$host$request_uri";
fastcgi_cache_use_stale error timeout invalid_header updating http_500 http_503;

# 2. Define exceptions in the server block (Carts, checkouts, logged-in users)
set $skip_cache 0;

if ($request_method = POST) {
    set $skip_cache 1;
}
if ($query_string != "") {
    set $skip_cache 1;
}
if ($request_uri ~* "/wp-admin/|/xmlrpc.php|wp-.*.php|/cart/|/checkout/|/my-account/") {
    set $skip_cache 1;
}
if ($http_cookie ~* "comment_author|wordpress_[a-f0-9]+|wp-postpass|wordpress_no_cache|wordpress_logged_in") {
    set $skip_cache 1;
}

# 3. Connect cache in the PHP location block
location ~ .php$ {
    fastcgi_cache WORDPRESS;
    fastcgi_cache_valid 200 301 302 10s;
    fastcgi_cache_bypass $skip_cache;
    fastcgi_no_cache $skip_cache;
    add_header X-FastCGI-Cache $upstream_cache_status;
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.2-fpm.sock;
}

Step 3 - Performance Comparison Before and After

This kind of stability is also demonstrated by modern website development with clean code, as evidenced by real metrics from a test with 200 active users:

Frequently Asked Questions About Server Performance and Microcaching