2 technical sections are folded below. Open the ones you are curious about, or all of them.

In short

I wanted real numbers before choosing how to build websites, not opinions. So the same small blog was built with 13 different technologies, from plain HTML to WordPress, and every version was measured the same way on two rented Google Cloud machines.

The clearest result: when the pages are generated in advance (prerendered), it barely matters which framework made them. Every one of those versions served about 17,000 pages a second from a small two-core server. What still differs is how much code the visitor’s phone has to download and run before the page reacts: from almost nothing with Astro to 140 KB with Next.js.

When the server builds every page on each request, the differences are large: Go served 3,427 pages a second, WordPress 50 and Ghost 42 on the same machine. A page cache brings WordPress and Ghost back to over 12,000. The project, the code and every raw number are public; the technical sections below are folded.

The whole benchmark in 104 seconds, with captions. Every number on screen comes from the same results as the charts below.
Bar chart of requests per second when every page is rendered on request on a 2-vCPU server: Go 3,427, Astro 1,631, SvelteKit 979, React Router 487, Nuxt 288, Qwik City 214, Laravel Octane 208, Next.js 168, Laravel PHP-FPM 144, Angular 123, WordPress 50, Ghost 42; every static build serves 16,600 to 18,300.
Post pages per second with every page rendered on request, no cache, on a 2-vCPU VM. The grey line is where every prerendered build lands.

The benchmark on GitHub ↗Findings: what the numbers mean ↗

Why I measured it

This site is built with Nuxt and prerendered onto Cloudflare Pages. When I planned the next projects I wanted to compare it with the alternatives people usually suggest: Next.js, WordPress, and plain HTML served by nginx. Comparisons online tend to measure one thing, usually requests per second on a hello-world page, on hardware nobody can reproduce.

I added the frameworks that keep coming up in the same conversations: Astro, SvelteKit, React Router (the successor of Remix), Angular and Qwik City, plus Hugo as a classic static site generator, Go with its standard library, htmx on top of Go, Laravel, and Ghost as the other popular blogging platform. Speed was only one of the questions. I also wanted to know how hard each one is to maintain, what it offers for analytics and monitoring, how it behaves when things go wrong, and how much work it takes to build the same thing.

One blog, built 15 times

Every version builds the same site, called Field Notes: a home page, a blog index with search and tag filters that work without reloading the page, 40 posts with code blocks and images, an about page, a 404 page, an RSS feed and a sitemap. The content, the stylesheet and the images are shared, so only the technology changes.

A hand-written HTML version is the reference. A checker compares every other version against it: the same markup, links, titles and status codes, plus a real browser that types in the search box, clicks the tag filters and toggles dark mode. A version is measured only after it passes all 1,214 checks (1,257 for versions that also filter on the server).

The implementations were written by AI coding agents from the same brief, one per framework, each recording its versions, decisions and every place the framework fought back. That makes the comparison consistent, but it also means the effort numbers describe how hard each framework was to get exactly right, not how long a person would take.

The Field Notes blog index with the Go tag selected: a search box, eleven tag chips with Go highlighted, the text Showing 13 of 40 posts, and three post cards with abstract covers.
The reference site, filtered by tag. All 24 versions render this page with the same markup.

The site contract ↗The conformance checker ↗

Two virtual machines in the same Google Cloud zone in Milan. The target is an n2-standard-2, two vCPUs and 8 GB, which is what a small VPS looks like, and it runs nothing but the version under test, in Docker. A separate n2-standard-4 runs the load generator, the browser and the harness, which drives the target over SSH. Load and target never share hardware.

Frameworks that can do both are measured twice. Static mode prerenders every page and serves the files with the same nginx configuration. Server mode renders every page on every request with no cache at all, which is the worst case on purpose: it measures the rendering engine. WordPress and Ghost also get a cached mode, an nginx page cache in front, because that is how they are normally run.

Each version then goes through the same phases. A cold Docker build, timed. Load with oha at 10 and 100 concurrent connections on five routes, recording throughput, latency, CPU and memory from the container cgroups. Lighthouse on three pages. A Playwright run on a throttled phone profile that measures when the tag filter starts working. Robustness probes, overload, a three-minute soak, a crash and, for the CMSs, a database outage. Finally a dependency count and a Trivy vulnerability scan of every image.

bench/cloud/create-vms.sh          # two VMs, Docker, the harness, SSH between them
source bench/cloud/env.sh <target-ip>
bench/run-all.sh                    # build, conformance, load, lighthouse, interact, robust, code
node bench/report.mjs               # regenerate docs/results.md

Methodology ↗oha, the load generator ↗Google Cloud N2 machine types ↗

The first complete run happened on my home server, and checking it found four problems in my own harness. The processor has four cores with two threads each, and logical CPU 0 shares a physical core with CPU 4: the load generator on CPUs 4 to 7 was competing with the target on 0 and 1 through hyperthreading. Docker was parsing tens of thousands of access-log lines a second and took most of a core, on whichever core it liked. The load generator asked for gzip, so the frameworks that compress by default did extra work the others skipped. And two probes were wrong: a supposed reflected XSS in Astro was a script tag inside a quoted attribute, which browsers never run, and a page cache made a crashed WordPress look healthy.

Each fix is in the repository. Then the overnight restart of another service on the same machine killed the corrected run. That is when I moved the measurements to two dedicated cloud machines: a benchmark that shares its hardware with everything else measures everything else too.

Serving pages

Prerendered, every version served the post page at 16,600 to 18,300 requests per second with 3.4 MB of server memory. The framework does not matter here, because nginx is serving files. The one visible exception is page weight: Next.js and Qwik embed their client data in the HTML, so their blog index is 109 KB and 147 KB against 45 KB for the reference, and those two pages served only 10,900 and 7,900 requests per second.

Rendered on every request, the cost of one post page in CPU time ranges from half a millisecond to 37 milliseconds: Go 0.54 ms, Astro 0.71, SvelteKit 1.3, React Router 2.4, Nuxt 5.1, Qwik 6.1, Next.js 8.0, Laravel on Octane 9.2, Angular 11, Laravel on PHP-FPM 13, Ghost 30 and WordPress 37.5. List pages cost two to seven times more. The Node servers also used only 1.1 to 1.5 of the two vCPUs, while Go and PHP used nearly both.

All load results ↗

What the visitor downloads

The interactive parts are the same everywhere: a dark mode switch and the blog filter. Each framework built them its own way, and the amount of code the browser receives for the blog index differs a lot:

On a throttled phone, the filter starts responding after 0.55 seconds when there is no client framework, Astro included, about one second with Qwik and htmx, 1.1 with SvelteKit, 1.4 with Angular and Nuxt, and 1.6 to 1.8 with React Router and Next.js. Lighthouse scored every page between 93 and 100, so these differences are easy to miss in a single score.

  • Astro: no script files, 1.5 KB of inline script.
  • Plain HTML, Hugo, Go, Laravel, WordPress and Ghost (one shared vanilla script): 1.2 KB.
  • Go with htmx: 18 KB.
  • SvelteKit: 44 KB, plus 19 KB inline.
  • Qwik City: 47 KB, plus 63 KB of serialized state inline.
  • Nuxt: 86 KB. Angular: 97 KB.
  • React Router: 119 KB, plus 23 KB inline.
  • Next.js: 140 KB, plus a 74 KB inline payload.
Scatter chart of JavaScript downloaded on the blog index against the time until the filter works on a throttled phone: plain HTML and Astro near 0 KB and 550 ms, Go with htmx 18 KB and 1,046 ms, SvelteKit 44 KB and 1,118 ms, Qwik 47 KB and 976 ms, Nuxt 86 KB and 1,462 ms, Angular 97 KB and 1,419 ms, React Router 119 KB and 1,642 ms, Next.js 140 KB and 1,831 ms.
JavaScript files on the blog index against the time until the tag filter works, on a phone profile with a 4× slower CPU and a 1.6 Mbps connection. Each stack’s static build where it has one.

Under stress

At 1,000 simultaneous connections, the prerendered versions, Go, Laravel on Octane and the cached WordPress and Ghost finished every request within ten seconds. The server-rendered Node versions finished 58 to 94 percent, and uncached WordPress and Ghost 29 percent. Those failures are mostly visitors giving up, not crashes: the server simply could not keep up.

A few specific gaps showed up. Angular and Qwik in server mode answered a malformed address with a server error. Astro, Angular and Qwik in server mode, and uncached Ghost, took the full ten seconds Docker allows to stop, which suggests their servers ignore the shutdown signal. With the database stopped, uncached WordPress returned errors, while the cached WordPress and Ghost kept serving pages from the cache. No version reflected the injected script or exposed a configuration or source file.

Robustness results ↗

Beyond speed

The rest of the comparison comes from research with a source for every claim, and from what happened while building the same site everywhere:

  • Maintenance: Go promises compatibility and needs no dependencies; Angular and Laravel publish yearly releases with two years of fixes. Qwik’s next major spent about 16 months in beta, and Ghost’s only policy is to run the latest release.
  • Security history: Next.js had 66 advisories in two years, seven of them critical; Ghost had 70 in 2026 alone, including an unauthenticated SQL injection. Prerendered output only exposes nginx.
  • Monitoring: Laravel has its own tools (Pulse, Telescope, Nightwatch), Go ships profiling and structured logging, Next.js and SvelteKit have built-in tracing.
  • Analytics: nothing is really included. Ghost comes closest with native analytics, which self-hosters only get through an extra service; elsewhere it is a plugin or a script tag.
  • Effort: Astro needed no workarounds and the least code among the JavaScript frameworks. Next.js needed a rewrite to return a proper 404 page, Nuxt an undocumented experimental option, and Ghost a set of nginx rewrites.
  • Editing: only WordPress and Ghost give non-developers an editor out of the box.

Research notes per stack ↗Per-stack ratings and rubrics ↗

What I take from it

For a content site like this one, prerendering matters more than the framework. Every prerendered version served pages equally well, so the choice comes down to how much JavaScript you are willing to send, how pleasant the framework is to work with, and who edits the content. Nuxt, prerendered on Cloudflare Pages, holds up; Astro would send less JavaScript for the same pages.

When pages have to be built on each request on a small server, Go, Astro and SvelteKit give several times more headroom than the rest. When people who do not write code need to edit the site, WordPress or Ghost make sense, but only behind a page cache: uncached, they served 50 and 42 pages a second and failed most requests under load.

Limits

Every configuration ran once (Lighthouse three times, the phone test five times), on cloud machines that share hardware with other customers; identical nginx versions varied by about ten percent, so smaller differences are noise. The site is small and mostly content, and server mode is uncached on purpose, so real deployments of the Node frameworks would sit closer to the prerendered numbers. The repository has everything needed to rerun it, including the scripts that create and delete the two machines.