Why I Moved My Stack to the Edge
I spent nearly a decade building APIs with Node.js and Express. It was the industry standard, and it worked reliably for years. But as my user base grew more global, the limitations of centralized servers became impossible to ignore. Latency is the silent killer of conversion rates. When a user in Singapore hits a server in US-East-1, they experience a 200ms to 300ms delay before the first byte even moves. That lag is palpable.
Six months ago, I migrated three high-traffic microservices to Cloudflare Workers using Hono.js. This wasn’t just a framework swap; it was a complete rethink of our infrastructure. Instead of idling in a single data center, my API now lives on Cloudflare’s global network. It executes at the edge, mere miles from the end user. After half a year in production, the results are clear: response times have plummeted, and our infrastructure overhead has almost vanished.
The Comparison: Express vs. Hono.js
If you know Express, Hono.js will feel like home, just without the 2010-era bloat. Express was built for the Node.js runtime, which carries significant legacy weight. Cloudflare Workers run on the V8 isolate engine—the same high-speed tech inside the Chrome browser. Because this environment doesn’t support the full Node.js standard library, you need a framework built for modern Web Standards.
- Runtime Overhead: A typical Express container might take 200MB of RAM just to sit idle. Hono is ultra-lightweight, coming in at under 14KB. It’s built entirely on the Fetch API, making it feel native to the modern web.
- Developer Experience: Express relies on aging callback patterns. Hono treats TypeScript as a first-class citizen. You get perfect IDE autocompletion for your routes and variables without any extra configuration.
- Routing Speed: Hono uses a RegexpRouter. Unlike the linear search method used by older frameworks, Hono matches routes in constant time. Even with hundreds of endpoints, your routing overhead remains negligible.
The Reality of 6 Months in Production
The Wins
The most immediate win was the death of the cold start. On AWS Lambda, a function might take two seconds to ‘wake up’ after a period of inactivity. Cloudflare Workers start in less than 5 milliseconds. To the user, the API feels instantaneous.
Cost efficiency has been staggering. We replaced a $120/month cluster of virtual machines with a $5/month Cloudflare Workers plan. Since you only pay for actual execution time rather than idle CPU cycles, our infrastructure bills dropped by roughly 75%. For a startup, that is a massive amount of runway reclaimed.
Vendor flexibility is the third major benefit. Because Hono adheres to standard Web APIs (Request/Response), the code isn’t proprietary. If I want to move this API to Deno, Bun, or a standard Node.js server tomorrow, I can do it with minimal refactoring. I am no longer locked into a specific cloud provider’s SDK.
The Challenges
It hasn’t been all sunshine. The V8 isolate environment has a strict 128MB memory limit on the standard plan. If you need to perform heavy image processing or manipulate massive CSV files in-memory, you will hit a wall. You also cannot use Node.js libraries that rely on C++ addons or the local filesystem. You must audit every dependency to ensure it is ‘Worker-compatible’ before hitting deploy.
My Recommended Production Structure
Don’t just cram everything into a single file. For a maintainable API, you need a structure that stays clean as you scale. I’ve found this layout works best for team collaboration.
project-root/
├── src/
│ ├── index.ts # The main entry point
│ ├── routes/ # Feature-based routing (users, posts, etc.)
│ ├── middleware/ # Auth, custom logging, and CORS
│ └── db/ # D1 or KV database bindings
├── wrangler.toml # Environment variables and config
├── package.json
└── tsconfig.jsonI highly recommend using Wrangler, Cloudflare’s CLI. It simulates the edge environment locally. This effectively eliminates the ‘it works on my machine’ bugs that plague traditional serverless development.
Quick Start: From Zero to Edge
Setting up is fast. You can have a production-ready scaffold in about thirty seconds. Start by running the Hono initializer.
npm create hono@latest my-apiChoose `cloudflare-workers` when the prompt appears. Here is how I structure a standard `index.ts` to include essential middleware and clean routing.
import { Hono } from 'hono'
import { logger } from 'hono/logger'
import { cors } from 'hono/cors'
const app = new Hono()
// Global Middleware
app.use('*', logger())
app.use('/api/*', cors())
// Simple Health Check
app.get('/', (c) => c.json({ status: 'online', location: 'edge' }))
// Dynamic Routes
app.get('/api/user/:id', (c) => {
const id = c.req.param('id')
return c.json({
userId: id,
timestamp: Date.now()
})
})
export default appConnecting to Data
A fast API needs fast data. Cloudflare offers D1, a serverless SQL database based on SQLite. Accessing it within Hono is straightforward and requires zero boilerplate connection logic.
app.get('/api/posts', async (c) => {
// Access the DB binding from the environment
const { results } = await c.env.DB.prepare(
'SELECT id, title FROM posts LIMIT 5'
).all()
return c.json(results)
})The 30-Second Deployment
Deployment is the best part of the workflow. Once you’ve authenticated, just run:
npm run deployYour code is optimized, bundled, and pushed to over 300 data centers globally. This happens in under 30 seconds. This speed has changed how our team works; we now ship small, incremental updates multiple times a day instead of doing massive, risky weekly releases.
Final Verdict
Switching to Hono.js on Cloudflare Workers has removed the most tedious parts of my job. I no longer spend weekends patching Linux kernels or worrying about auto-scaling groups. The infrastructure handles millions of requests as easily as it handles ten. If you are starting a new project, look past the traditional Express stack. The performance boost for your users and the peace of mind for you are simply too good to pass up.
