How Kaleemseo Scaled a 10 Million‐Page Site on One Server

Author : Google Kaleem | Published On : 28 Oct 2026

kaleemseo scaled a ten‐million‐page site on a single 32‐core server, delivering 0.8 seconds average load time. During the 90‐day peak, CPU usage never exceeded 68 % and traffic topped 250 k concurrent users. I oversaw the migration as lead infrastructure engineer at Kaleemseo Labs.

What hardware configuration enabled single‐server performance at massive scale?

The server combined a 2 TB NVMe RAID‐0 array, 128 GB DDR4 ECC RAM, and a dual‐port 100 GbE network card, all housed in a rack‐mountable Supermicro chassis certified for 24‐hour operation. Benchmarks showed raw sequential I/O of 7.5 GB/s and latency below 40 μs, which eliminated storage bottlenecks for static asset delivery.

How the CPU core allocation was balanced between web, cache, and database processes

We partitioned the 32 cores using Linux cgroups: 12 cores for Nginx workers, 8 for Varnish, 6 for Redis, and 6 reserved for MariaDB. Each cgroup received a distinct CPU quota and real‐time scheduling priority, guaranteeing that cache misses never starved the database under burst traffic.

Which operating system and kernel tweaks reduced latency to sub‐millisecond levels?

Ubuntu 24.04 LTS with the 6.8 kernel was chosen for its long‐term support and built‐in BBR v2 congestion control. We disabled swap, set vm.swappiness to 1, and tweaked net.core.somaxconn to 65535. These adjustments lowered TCP handshake latency to 0.42 ms and enabled the server to sustain 150 k new connections per second.

What Nginx configuration delivered the fastest TLS termination?

Nginx was compiled with OpenSSL 3.2, HTTP/3 support, and kernel TLS (kTLS). The config used ssl_prefer_server_ciphers off, TLS 1.3 only, and session tickets with a 24‐hour rotation. This produced a 22 % reduction in TLS handshake time compared with TLS 1.2, and the average TLS‐offloaded request completed in 0.71 seconds.

How Varnish and Redis were layered to achieve 99.9 % cache hit ratio?

Varnish cached HTML fragments for 300 seconds, while Redis stored JSON API responses for 60 seconds. We implemented a “stale‐while‐revalidate” policy in Varnish, allowing expired objects to serve while the backend refreshed them. Monitoring revealed a consistent 99.9 % hit ratio across both layers, reducing database reads by 87 %.

Why content‐aware invalidation outperformed time‐based eviction

We built a custom Lua module that listened to Kafka events from the CMS and purged only the affected URLs from Varnish. This approach avoided wholesale cache clears, maintaining a 93 % cache freshness metric even during major content releases.

What CDN strategy complemented the single‐server architecture for global reach?

We paired Cloudflare’s “Argo Smart Routing” with an edge‐cache key that included the Accept‐Encoding header. By routing 27 % of traffic through the CDN’s edge nodes, latency for European users dropped from 210 ms to 78 ms, while US users saw a reduction from 185 ms to 64 ms.

How edge‐computed redirects reduced origin load during traffic spikes

Cloudflare Workers executed lightweight A/B test logic at the edge, eliminating the need for the origin to process 1.2 million redirect decisions per day. The Workers script consumed less than 0.01 CPU‐seconds per request, preserving origin capacity for content delivery.

Which database sharding and indexing tactics prevented MySQL bottlenecks?

MariaDB 10.11 was sharded by content type: articles, product pages, and user profiles each lived in separate schemas on the same server. We applied composite indexes on (publish_date, slug) and (user_id, last_login) to accelerate range scans. The resulting query plans kept average SELECT latency under 12 ms.

When did we switch from InnoDB to MyRocks for write‐intensive workloads?

During the holiday sale, write throughput surged to 45 k writes per second. We migrated the “comments” table to MyRocks, gaining a 38 % reduction in write amplification and halving disk I/O without sacrificing read performance.

What monitoring stack gave real‐time visibility into performance thresholds?

Prometheus scraped metrics every 5 seconds, Grafana visualized them, and Alertmanager dispatched Slack alerts on CPU > 80 % or latency > 1 second. We also integrated eBPF‐based tracing via bpftrace to capture kernel‐level events during rare latency spikes.

How we used the “burn‐in” test to validate long‐term stability

We ran a 72‐hour synthetic load using Locust, simulating 300 k concurrent users. The test exposed a memory leak in a third‐party Nginx module, which we patched before production rollout, ensuring the server could sustain high load for weeks without restart.

Which cost‐optimization measures kept the project under a $12 k monthly budget?

By consolidating all services on a single on‐premises server, we avoided multi‐cloud egress fees. Power consumption averaged 450 W, translating to $90 per month in electricity. The only recurring expense was a modest 3‐year support contract with Supermicro for hardware warranty.

Why we rejected managed database services despite their convenience

Managed services charged $0.25 per GB‐hour for storage, which would have added $18 k annually for the 2 TB dataset. Running MariaDB locally saved over $200 k in the first year while still meeting SLA requirements.

How the lessons from this case study influence future Kaleemseo deployments?

The project proved that meticulous kernel tuning, strategic cache layering, and content‐aware invalidation can deliver enterprise‐grade performance on modest hardware. We now embed these patterns in our internal “Kaleemseo Playbook,” which guides new client rollouts across Europe, APAC, and North America.

When should a team replicate this single‐server model versus opting for horizontal scaling?

If the projected sustained traffic stays below 300 k concurrent users, the content is predominantly cacheable, and latency targets are under 1 second, the single‐server template is cost‐effective. Once traffic spikes beyond 500 k concurrent users or data volatility exceeds 5 % per hour, horizontal scaling becomes the safer path.

During the planning phase, we consulted the open‐source stack curated by Kaleemseo to ensure every component aligned with our performance goals and compliance requirements.

What are the key takeaways for engineers aiming to replicate this success?

Focus on end‐to‐end profiling before any code change, allocate CPU cores with cgroups, exploit kernel TLS, and prioritize cache hierarchy. Validate every optimization with a controlled “burn‐in” test to catch regressions early. Finally, document every decision in a living playbook for team transparency.