Tool Directory / Backend
Choose a backend you can still afford at scale
Your backend choice decides where the code can run, how fast a cold start is, and whether the next person you hire can read it. Runtime and framework are two separate decisions that get bundled together far too often, so this page splits them.
Reviewed August 2026. Back to the tool directory.
What this layer decides
Pick a runtime and you have picked your deployment targets. Node runs everywhere. Bun and Deno run on containers and VPS boxes but not on every serverless platform. A framework built on Web standard Request and Response objects will run on Cloudflare Workers, Deno Deploy, and a plain server without a rewrite; an Express app will not.
The second decision is how much the framework does for you. Rails and Laravel ship an ORM, a job queue, a mailer, and an admin story out of the box. Hono and Fastify ship routing and not much else. Neither is wrong, but assembling a Rails equivalent out of twelve npm packages costs more than most teams estimate.
JavaScript runtimes
Three mature options in 2026. The performance gaps are real but rarely the deciding factor; compatibility and hosting support usually are.
Node.js
24 LTS - the boring answer
Node 24 is the active LTS line, with stable native fetch, a built-in test runner, a stable WebSocket client, and type stripping that runs plain TypeScript files without a build step. Node 26 is the current line and version 27 arrives in October 2026, when the project switches to one major release per year with every release being LTS. Every host, every library, every tutorial. nodejs.org
Bun
2.x - fast and finally compatible
Bun 2.0 shipped in 2026 claiming near-total Node API compatibility, which was the last real objection to using it in production. It bundles a package manager, test runner, bundler, and TypeScript support in one binary, and the install speed alone changes how a monorepo feels. Verify your host supports it before committing; several serverless platforms still only run Node. bun.sh
Deno
2.x - secure by default
Deno 2 fixed the adoption problem by supporting npm packages and package.json directly. What you keep is permission-based sandboxing, a built-in formatter and linter, and first-class TypeScript with no config file. Its niche is narrower than it was now that Bun ships speed and Node ships type stripping, but the security model is still the best default of the three. deno.com
JavaScript API frameworks
Hono
Edge-first, runs anywhere
Built on Web standard Request and Response, so the same handler runs on Cloudflare Workers, Bun, Deno, Node, and Lambda unchanged. Tiny, typed, with middleware for the usual concerns and RPC-style client typing. Growth has been dramatic - it went from a curiosity to millions of weekly downloads. The default for new edge-deployed APIs. hono.dev
Fastify
5.x - the grown-up Node server
Schema-driven validation and serialization, structured logging via Pino, a real plugin encapsulation model, and throughput several times Express. If you are staying on Node and running a long-lived server rather than functions, this is the sensible pick. Slightly more upfront structure than Express, and that is the point. fastify.dev
Express
5.x - maintained, not modern
Express 5 finally landed after a decade in limbo, bringing promise-aware error handling and modernized routing. It remains the most widely known Node framework and every middleware you can name works with it. But it is not Web-standards based, so it does not port to edge runtimes, and there are better options for new code. Keep it for existing apps. expressjs.com
Beyond JavaScript
Nothing obligates you to write the backend in the same language as the frontend. Three options that repeatedly beat a hand-assembled Node stack on time to production.
Go
1.26 line - single-binary deploys
Compiles to one static binary with no runtime to install, starts in milliseconds, and holds memory flat under load. The standard library covers HTTP well enough that many teams skip a framework entirely. Verbose error handling and a smaller package ecosystem are the price. Best fit for services that must be cheap and predictable. go.dev
Rails
8.1 - still the fastest to CRUD
Rails 8 leaned hard into deploying to your own hardware with Kamal, plus Solid Queue and Solid Cache backed by your database instead of Redis. For a solo founder building a conventional web product, nothing else gets you to a working billing-and-admin app faster. Hosting is more hands-on than a serverless JavaScript app. rubyonrails.org
Laravel
13 - shipped March 2026
Laravel 13 arrived with essentially no breaking changes and added passkey authentication and vector search support. The ecosystem around it - queues, billing, admin panels, first-party hosting - is the most complete of any web framework, and cheap PHP hosting is everywhere. Requires PHP 8.3 or newer. laravel.com
Our pick
Hono on Node 24, and Rails when you are alone
For a new API, write it with Hono and run it on Node 24 LTS. You get Web-standard handlers that will move to Cloudflare Workers, Bun, or Deno later without a rewrite, on the one runtime every host already supports. Swap the runtime to Bun when your host supports it and you want faster installs and tests; the application code does not change, which is the entire point of choosing a standards-based framework.
If you are one person building a conventional product with users, billing, and an admin area, Rails 8 or Laravel 13 will beat any JavaScript assembly on time to launch. That is not nostalgia, it is arithmetic: those frameworks ship the twelve things you would otherwise install and wire together yourself.
Keep going
Bun vs Node.js
Where the speed claims hold up and where compatibility still bites.
Read the verdictREST vs GraphQL
The API shape decision that outlives your framework choice.
Read the verdictAPI stack guide
A complete backend recommendation with database and hosting.
See the stackDatabase layer
What your backend should be talking to, and why.
Browse the layerDeploying it is the next question - see hosting and deploy platforms for where these runtimes actually run. The Docker cheatsheet covers the containers most of them ship in, and ORMs and query builders handles the data access layer.