Hono.js: the backend framework built for the edge — and why it's going mainstream

Hono shipped in 2021 as a tiny framework for Cloudflare Workers. In 2026, it runs unchanged on Workers, Deno, Bun, Node.js, AWS Lambda, Vercel, and Fastly Compute — the same code, the same API, every runtime. Cloudflare, Deno, and Unkey use it in production. It's under 12kB, has zero dependencies, and has first-class TypeScript support with a type inference system that makes tRPC-style type safety achievable in a traditional REST API.

What makes it different

Most Node.js frameworks (Express, Fastify, Koa) are built on Node's http module. Hono is built on the Web Standards API — Request, Response, URL, Headers — which is why it runs everywhere those APIs exist. This isn't just portability; it means your Hono routes behave identically across runtimes because the underlying primitives are the same. There's no translation layer, no adapter surface, no 'works on Node but not on Workers' category of bugs.

import { Hono } from 'hono';
import { zValidator } from '@hono/zod-validator';
import { z } from 'zod';

const app = new Hono();

const postSchema = z.object({
  title: z.string().min(1).max(200),
  body: z.string().min(1),
});

app.post('/posts', zValidator('json', postSchema), async (c) => {
  const { title, body } = c.req.valid('json'); // fully typed
  const post = await db.posts.create({ title, body });
  return c.json(post, 201);
});

export default app; // works on Workers, Bun, Node — unchanged

RPC mode: end-to-end types without codegen

Hono's RPC client infers the full type of your API from the router definition — request body, path params, query strings, and response shape — and makes those types available to a typed fetch client without any code generation step. It covers the 80% case: internal TypeScript clients that want type-safe API calls with minimal tooling. Not as seamless as tRPC (types live at the HTTP layer, not the function layer), but a significant improvement over untyped REST clients.

When to pick Hono vs alternatives

• Pick Hono for new TypeScript APIs on any runtime, especially edge and serverless targets.
• Pick tRPC for full-stack TypeScript where frontend and backend share a monorepo and end-to-end type inference is the priority.
• Pick Fastify for Node.js APIs where you need the widest plugin ecosystem.
• Don't pick Express for new projects — no native TypeScript types, synchronous by design, hasn't evolved meaningfully since 2015.

Written by Appesto Engineering.