How to Build a Serverless API with Bun and Hono: Step-by-Step Guide

How to Build a Serverless API with Bun and Hono

Curious about developing a modern serverless API that’s both fast and lightweight? With the combination of Bun and Hono, developers gain a cutting-edge stack designed for efficiency, simplicity, and speed. This walkthrough examines Bun and Hono’s unique advantages and delivers a practical, guided build to help anyone create a serverless sum API from scratch.

Why Choose Bun and Hono for Your API?

Innovation in JavaScript backends has rapidly accelerated. While Node.js remains prominent due to its vast ecosystem and familiarity, new platforms are engineered for performance and streamlined developer experiences. Bun, launched in 2021, is specifically tuned to run JavaScript quickly, modernize workflows, and reduce unnecessary installation steps. Hono, released around the same time, is celebrated as an ultrafast web framework leveraging open standards and working seamlessly across Bun, Deno, and even Node.js with minimal adapters.

Selecting Bun and Hono means benefitting from:

Lightning-fast response times
Minimal configuration and straightforward setup
TypeScript compatibility for safer coding
Native serverless support across popular cloud providers

Comparing Popular JavaScript API Stacks

For context, traditional Node.js with Express is known for being robust but heavy, which may slow startups and increase memory use. Deno with Oak is another modern contender that integrates security and streamlined tooling by default. However, Bun with Hono distinguishes itself through sheer performance and ease of use, making it a compelling choice for rapid serverless development.

Key Prerequisites Before You Start

To ensure a smooth build process, make sure the following tools are ready on your system:

Bun runtime and package manager, properly installed
An integrated development environment such as VS Code
A foundational understanding of programming concepts

Setting Up a Bun and Hono API Project

Getting started involves initializing a fresh project directory, installing the necessary runtime, and configuring the simplest starter files. Here’s how to prepare your workspace:

Step 1:
Open a terminal and install Bun:

textbun install

Step 2:
Initialize a new Hono project using the official templates:

textbun create hono hono-api
cd hono-api

During this stage, select the “bun” template and confirm dependency management with Bun’s package manager.

Step 3:
The key project files are:

src/index.ts – Main backend API logic
test.html – Basic HTML front-end to interact with your API

Writing the Serverless API Logic

The backend code for this tutorial is broken into clear, practical steps.

1. Importing Libraries and Initializing the App

Start by pulling in the necessary Hono and CORS modules, then create the app instance to serve requests.

typescriptimport { Hono } from 'hono';
import { cors } from 'hono/cors';

const app = new Hono();
app.use('*', cors());

2. Setting Up In-Memory Storage

A simple array stores all sum calculations performed by users.

typescriptconst results: { a: number; b: number; sum: number }[] = [];

3. Defining API Endpoints

Root endpoint responds with a plain message
/api/greet/:name greets users by name (pulled from the URL)
/api/sum (POST) receives two numbers, validates them, returns the sum, and logs the operation to memory
/api/sum (GET) fetches all stored results

typescriptapp.get('/', (c) => c.text('Hello, world!'));

app.get('/api/greet/:name', (c) => {
  const name = c.req.param('name');
  return c.json({ message: `Hello, ${name}!` });
});

app.post('/api/sum', async (c) => {
  try {
    const { a, b } = await c.req.json();
    if (typeof a !== 'number' || typeof b !== 'number') {
      return c.json({ error: 'Both a and b must be numbers.' }, 400);
    }
    const sum = a + b;
    results.push({ a, b, sum }); // Store in memory
    console.log('Stored sums:', results);
    return c.json({ sum });
  } catch (err) {
    return c.json({ error: 'Invalid JSON body.' }, 400);
  }
});

app.get('/api/sum', (c) => {
  return c.json(results);
});

export default app;

Building a Simple Front-End Interface

The accompanying test.html file enables quick client-side testing. Users can input two numbers, submit them to the backend, and visualize the returned sum directly in their browser. The backend logs all sum operations, which can be reviewed in the server terminal.

xml<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Test Sum API</title>
</head>
<body>
  <h1>Sum API Test</h1>
  <input id="num1" type="number" placeholder="Enter first number" />
  <input id="num2" type="number" placeholder="Enter second number" />
  <button onclick="callSum()">Calculate Sum</button>
  <p id="result"></p>
  <script>
    async function callSum() {
      const a = Number(document.getElementById('num1').value)
      const b = Number(document.getElementById('num2').value)
      const response = await fetch('http://localhost:3000/api/sum', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ a, b })
      })
      const data = await response.json()
      document.getElementById('result').innerText = JSON.stringify(data)
    }
  </script>
</body>
</html>

Running and Testing the Serverless API

Once setup is complete, launch the API using the Bun runtime:

textbun run src/index.ts

Open test.html in any browser to access the input form. Submitting two numbers instantly returns their sum, and all requested operations are visible in the terminal output for further validation.

Conclusion: Fast, Modern APIs with Bun and Hono

Leveraging Bun and Hono empowers teams to build high-speed, minimal-overhead serverless APIs. This architecture demonstrates streamlined development and instant serverless readiness, letting engineers focus on innovative business logic instead of boilerplate code.

Read more such articles from our Newsletter here.