Hono.js in 2026: The Ultralight Backend Running on Edge, Bun and Node

// Hono in 2026 — same code on Cloudflare, Bun, Deno and Node
import { Hono } from 'hono'

const app = new Hono()

app.get('/', (c) => c.text('Hello from the edge! ⚡'))

app.get('/api/users/:id', async (c) => {
  const id = c.req.param('id') // auto-typed
  const user = await c.env.DB.prepare('SELECT * FROM users WHERE id = ?').bind(id).first()
  return c.json(user)
})

// One handler, 4 runtimes:
// - Cloudflare Workers: export default app
// - Bun: Bun.serve({ fetch: app.fetch })
// - Deno: Deno.serve(app.fetch)
// - Node: serve(app) with @hono/node-server
export default app

// server.ts — API with Zod validation + RPC (2026)
import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'

const app = new Hono()
  .get('/api/posts', async (c) => {
    const posts = await db.posts.findMany()
    return c.json({ posts })
  })
  .post('/api/posts', zValidator('json', z.object({
    title: z.string().min(3),
    content: z.string().min(10)
  })), async (c) => {
    const { title, content } = c.req.valid('json') // 100% typed
    const post = await db.posts.create({ data: { title, content } })
    return c.json(post, 201)
  })

export type AppType = typeof app // ← that's all you need

// client.ts — type-safe client without generating anything
import { hc } from 'hono/client'
import type { AppType } from './server'

const client = hc<AppType>('http://localhost:3000')

// Full autocomplete, error if body doesn't satisfy Zod
const res = await client.api.posts.$post({
  json: { title: 'My post', content: 'Long content...' }
})
if (res.ok) {
  const post = await res.json() // inferred type: { id: string, title: string, ... }
}

// ❌ Compile-time error if you mess up
await client.api.posts.$post({ json: { title: 'ab' } }) // title min 3 → TS error

import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { logger } from 'hono/logger'
import { bearerAuth } from 'hono/bearer-auth'
import { cache } from 'hono/cache'

const app = new Hono()

// Prod stack 2026 — 5 lines
app.use('*', logger())
app.use('/api/*', cors({ origin: ['https://myapp.com'], credentials: true }))
app.use('/api/admin/*', bearerAuth({ token: process.env.ADMIN_TOKEN! }))
app.use('/api/posts/*', cache({ cacheName: 'posts', cacheControl: 'max-age=60' }))

// Auth with Better Auth / Clerk / Lucia in 2026
import { auth } from './auth' // Better Auth on Hono is 1 line

app.use('*', async (c, next) => {
  const session = await auth.api.getSession({ headers: c.req.header() })
  c.set('user', session?.user)
  await next()
})

app.get('/api/me', (c) => {
  const user = c.get('user')
  if (!user) return c.json({ error: 'Unauthorized' }, 401)
  return c.json(user)
})

// Migration Express → Hono in 10 minutes (2026)
// Express:
app.get('/api/users/:id', (req, res) => {
  res.json({ id: req.params.id })
})
// Hono:
app.get('/api/users/:id', (c) => c.json({ id: c.req.param('id') }))
// Differences: c.req.param vs req.params, c.json vs res.json, return c.* in Hono

// wrangler.toml — Cloudflare Workers (2026)
name = "my-hono-api"
main = "src/index.ts"
compatibility_date = "2026-06-01"

[vars]
NODE_ENV = "production"

[[d1_databases]]
binding = "DB"
database_name = "my-db"
database_id = "xxxx"

// src/index.ts — same app on 3 targets
import { Hono } from 'hono'
const app = new Hono<{ Bindings: { DB: D1Database } }>()

app.get('/api/health', (c) => c.json({ ok: true, region: c.env.CF_REGION }))

// Cloudflare Workers
export default app
// Bun (local ultra-fast dev): Bun.serve({ fetch: app.fetch, port: 3000 })
// Node (fallback): import { serve } from '@hono/node-server'; serve({ fetch: app.fetch, port: 3000 })

# Dev with Bun (40ms HMR) + deploy to Workers (global)
bun install hono
bun run dev          # Bun -- 40ms HMR, 0 config
bunx wrangler deploy # Cloudflare -- 18ms global, 0 cold start

# Vercel Edge (same code)
# vercel.json: { "functions": { "api/index.ts": { "runtime": "edge" } } }

# Recommended 2026 architecture
frontend: TanStack Start or Next.js 16 (Vercel / Cloudflare Pages)
api: Hono 4.7 (Cloudflare Workers + D1/KV/R2)
db: Cloudflare D1 (edge SQLite) + Drizzle ORM or Neon Postgres
auth: Better Auth (native Hono support) or Clerk
validation: Zod + @hono/zod-validator
docs: hono-openapi → automatic Swagger UI
monitor: Sentry + Cloudflare Analytics

// src/db/schema.ts — Drizzle ORM (2026)
import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'
export const posts = sqliteTable('posts', {
  id: text('id').primaryKey(),
  title: text('title').notNull(),
  content: text('content').notNull(),
  createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
})

// src/routes/posts.ts — full CRUD with Hono + Drizzle + Zod
import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { drizzle } from 'drizzle-orm/d1'
import { posts } from '../db/schema'
import { z } from 'zod'

const postsApp = new Hono<{ Bindings: { DB: D1Database } }>()

postsApp.get('/', async (c) => {
  const db = drizzle(c.env.DB)
  const all = await db.select().from(posts).all()
  return c.json({ posts: all })
})

postsApp.post('/', zValidator('json', z.object({
  title: z.string().min(3).max(100),
  content: z.string().min(10)
})), async (c) => {
  const { title, content } = c.req.valid('json')
  const db = drizzle(c.env.DB)
  const id = crypto.randomUUID()
  await db.insert(posts).values({ id, title, content, createdAt: new Date() })
  return c.json({ id, title, content }, 201)
})

export default postsApp

// src/index.ts — mount sub-routers
import { Hono } from 'hono'
import postsApp from './routes/posts'

const app = new Hono()
app.route('/api/posts', postsApp)
app.get('/', (c) => c.text('Hono API 2026 🔥 18ms global'))
export default app