Why I fell in love with Hono

I wrote APIs in Express for years. It was the obvious starting point for anyone coming from the Node.js world: huge ecosystem, documentation everywhere, middleware for everything. Then came Fastify with its obsession with performance and its real-world schema validation — a real step up.

Then I tried Hono for a small project, almost by chance, and I never looked back.

What is Hono

Hono is an ultra-lightweight web framework written in TypeScript. The name comes from the Japanese 炎 — flame. It’s fast, small, and runs anywhere: Node.js, Deno, Bun, Cloudflare Workers, Vercel Edge Functions, AWS Lambda.

This last part is what makes the difference.

The problem Hono solves

Express and Fastify are tied to Node.js. They work great on a server, but they don’t run on edge runtimes like Cloudflare Workers or Vercel Edge Functions — environments that use standard Web APIs instead of Node APIs.

If you wanted server-side logic on the edge, you had to rewrite everything with different APIs, learn each platform’s quirks, and keep separate codebases.

Hono is built on Web Standard APIs — Request, Response, Headers, URL. The ones the browser already knows. The ones every modern runtime implements.

import { Hono } from "hono";

const app = new Hono();

app.get("/api/hello", (c) => {
  return c.json({ message: "hello" });
});

export default app;

This code runs identically on Node.js, Bun, Cloudflare Workers, and Vercel Edge. Zero changes.

What really convinced me

First-class Type Safety

With Express, types were an afterthought — @types/express was a separate package, and middleware broke type inference at every step. With Hono, TypeScript is at the core of the design.

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

const app = new Hono();

const schema = z.object({
  name: z.string().min(1),
  age: z.number().int().positive(),
});

app.post("/users", zValidator("json", schema), (c) => {
  const { name, age } = c.req.valid("json"); // typed, no cast needed
  return c.json({ name, age }, 201);
});

Composable Middleware without magic

In Express, middleware was a function with four arguments and a next() to call — an implicit contract that led to subtle bugs. In Hono, it’s an async function that uses await next() explicitly and readably.

Conclusion

Express taught me how a web framework works. Fastify showed me that performance can be designed. Hono made me realize that the runtime shouldn’t be an architectural constraint.