Coder Legion - Recent posts tagged bun

Building Web Servers with Node.js and Bun – A Backend Developer’s First Step

Mon, 28 Jul 2025 06:12:04 +0000

Welcome Back to the Backend Development Series!

In the previous post, we laid the groundwork:

✅ We explained what a web server is
✅ We explored the Client-Server Architecture
✅ We saw how JavaScript can run on the backend using Node.js and Bun
✅ And most importantly, we built our very first web server using Node’s built-in http module

But that server had one big limitation...

⚠️ The Problem With Our First Server

In our first server, no matter what URL you visited — whether it was /, /about, /ice-tea, or even /random-nonsense — the server would respond with the exact same message:

Hello from your first Node server!

Why? Because we didn’t check what URL the user was actually requesting.
We just responded blindly to every single request.

And that’s not how real-world websites work, right?

/login should show a login form
/about should show info about your site
/ice-tea should confirm your tea order ☕

This brings us to an important feature in every backend system:
Routing

What Is Routing?

Routing is the logic that tells your server:
➡️ “If a user visits this path (/), respond with this content.
If they visit that path (/ice-tea), respond differently.”

In simple terms:
Different URLs → Different responses

What You’ll Learn in This Blog

We’re going hands-on again — but this time, we’ll build two smart servers:

A Vanilla Node.js server (with manual routing using if-else)
A Bun server (with its built-in speedy tools)

By the end, you'll understand:

✅ How to respond to specific paths like /, /login, /ice-tea
✅ How routing works without any frameworks
✅ Why developer experience matters
✅ And why frameworks like Express.js were born to save our sanity

Let’s start with Node.js.

️ Building a Smarter Web Server in Node.js (Vanilla Style)

Step 1: Create a File

Create a new file named:

server-node.js

Step 2: Add This Code

const http = require("http");

const hostname = "127.0.0.1";
const port = 3000;

const server = http.createServer((req, res) => {
  if (req.url === "/") {
    res.statusCode = 200;
    res.setHeader("Content-Type", "text/plain");
    res.end("Hello, it's Ice Tea!");
  } else if (req.url === "/ice-tea") {
    res.statusCode = 200;
    res.setHeader("Content-Type", "text/plain");
    res.end("Thanks for ordering ice tea. It's really hot!");
  } else {
    res.statusCode = 404;
    res.setHeader("Content-Type", "text/plain");
    res.end("404 - Not Found");
  }
});

server.listen(port, hostname, () => {
  console.log(`Server is listening at http://${hostname}:${port}`);
});

What’s Happening Here?

Let’s break it down:

`req.url`

This gives us the path the user is trying to access. Examples:

/
/ice-tea
/something-weird

We use this value to decide what response to send back.

`if...else if...else`

This is basic routing logic:

If the user visits / → show the homepage
If they visit /ice-tea → give them a virtual cup ☕
If they visit anything else → show a 404 - Not Found message

▶️ How to Run It

Open your terminal
Run the server:

node server-node.js

Open your browser and go to:

http://127.0.0.1:3000/ → You’ll see: Hello, it's Ice Tea!
http://127.0.0.1:3000/ice-tea → You’ll see: Thanks for ordering ice tea. It's really hot!
http://127.0.0.1:3000/anything-else → You’ll see: 404 - Not Found

Why This Matters

In our first server (from the last post), we didn’t handle routes at all.
The result? Every request got the same reply. That’s not practical.

This version adds conditional logic — a baby step toward how real websites handle pages, endpoints, and APIs.

You’ve just built your first routing mechanism in Node.js!

Rebuilding the Same Server with Bun

We’ve already built a basic web server in Node.js using http.createServer and some conditional routing.

Now let’s recreate the exact same logic, but this time using Bun — the newer, faster JavaScript runtime that’s shaking up the backend ecosystem.

✅ If Node.js feels like a power drill, Bun is more like a Swiss Army knife — fast, modern, and loaded with built-in tools.

Step 1: Create a File

Create a new file named:

server-bun.js

Step 2: Add This Code

import { serve } from "bun";

serve({
  fetch(req) {
    const url = new URL(req.url);

    if (url.pathname === "/") {
      return new Response("Hello, it's Ice Tea!", { status: 200 });
    } else if (url.pathname === "/ice-tea") {
      return new Response("Ice tea is a good option!", { status: 200 });
    } else {
      return new Response("404 - Not Found", { status: 404 });
    }
  },
  port: 3000,
  hostname: "127.0.0.1"
});

What’s Going On Here?

Let’s break it down piece by piece:

✅ `import { serve } from "bun"`

No need for http module or third-party packages — Bun comes with serve built-in
This function spins up a server instantly with minimal setup

✅ `fetch(req)`

Instead of createServer((req, res) => {}), Bun uses a fetch()-like handler
If you've ever used fetch() in the browser, this will feel familiar
This function receives the request and is expected to return a Response object

✅ `new URL(req.url)`

This gives you an easy way to extract the pathname (like / or /ice-tea) from the request URL
Think of it like a more modern and cleaner way than parsing req.url manually in Node

✅ `return new Response(...)`

Just like the browser's fetch() API — you return a Response object with a body and status code

What You Just Did

You created a complete HTTP server using only 10 lines of code, with:

No external dependencies
No manual headers
No boilerplate setup

And it still behaves exactly like the Node.js version:

▶️ How to Run It

Make sure you have Bun installed. Then run:

bun server-bun.js

Now, visit these URLs in your browser:

URL	Response
`http://127.0.0.1:3000/`	`Hello, it's Ice Tea!`
`http://127.0.0.1:3000/ice-tea`	`Ice tea is a good option!`
`http://127.0.0.1:3000/random`	`404 - Not Found`

Key Learnings – Node.js vs Bun Syntax Comparison

Let’s break down how Node.js and Bun differ in terms of syntax and developer experience:

Feature	Node.js	Bun
Imports	`require("http")`	`import { serve } from "bun"`
Server creation	`http.createServer()`	`serve()`
Request object	`req.url`	`new URL(req.url)`
Response	`res.writeHead(), res.end()`	`return new Response(...)`
Port/Host setup	`server.listen(port, host)`	Included directly in `serve({})`
File support	CommonJS (`.js`)	ESM-first (`.js`, `.ts`, `.jsx`, etc.)
Auto Restart	❌ Manual restart required	❌ Not built-in (use `bunx nodemon` or `bun --watch`)

⚠️ The Problem: Code Reusability & Scalability

Let’s face it — even with just 3 routes, our if-else chain already looks messy.

Imagine managing 20+ routes in a real-world API this way.

Problem	Why It Matters
❌ Hard to read	Too much nesting, unclear logic
❌ Not modular	All logic in one file — no separation
❌ Difficult to test	No reusable structure, can't isolate parts

The Solution: Use a Framework

That’s why developers turn to backend frameworks — to make their code cleaner, modular, and scalable.

Some popular options:

Express (Node.js) – industry standard
Hono (Bun) – minimal, super fast
Fastify – fast, schema-based
Koa – modern, middleware-centric

These frameworks provide:

✅ Route grouping
✅ Middleware support (auth, logging, etc.)
✅ Centralized error handling
✅ Clean, readable syntax
✅ Better DX (Developer Experience)

What’s `Next`?

In the next blog, we’ll take things to the next level:

Explore backend frameworks (not just Express)
Start using Express.js to build cleaner, modular, and testable APIs
Learn about middleware, route grouping, and error handling

You’ve just taken your first real step toward backend mastery.
If you found this post helpful, just wait till we dive into frameworks — things are about to get way more powerful (and easier)!

Stay tuned.

Getting Started with Backend Development: Web Servers, Node.js, and Bun Explained

Sun, 20 Jul 2025 19:00:38 +0000

Hey everyone!
If you’re ready to dive into the world of backend development, you’re in the right place. This blog kicks off our backend dev series—where we’re going beyond the frontend and digging into the engines powering the web: servers, requests, runtime environments, and real-world backend architecture.

Whether you're aiming to build large-scale applications like Shopify or simple ToDo apps, understanding how a backend works is absolutely essential. And yes, we’ll write actual code along the way — not just talk theory.

Let’s get started!

What's the Prerequisite?

You only need one thing before jumping in:

Basic knowledge of JavaScript — just the fundamentals like variables, functions, and loops.

No need to master Node.js, Bun, or understand how backend protocols work. You don’t even need to know what a server really is.

This blog is designed for absolute beginners in backend development. We’ll start from scratch and build everything step by step — explaining not just the how, but also the why behind each concept.

By the end, backend buzzwords like HTTP, status codes, request/response cycle, and routing will feel like second nature.

Understanding Backend Architecture

Before we jump into the code, let’s take a moment to understand what we’re actually building and how it fits into the bigger picture of web development.

Client-Server Architecture

At the heart of every backend system lies a simple but powerful concept: the client-server model.

Client (Browser / Mobile App) → Web Server → Database (Optional)

Client: This is the user-facing side — it could be a browser, mobile app, smartwatch, or anything capable of making a request.
Web Server: The brain of your backend. It receives client requests, processes them, and sends back a response. This is our main focus in this series.
Database (not covered yet): A place to store, retrieve, and manage data. Examples include MongoDB, PostgreSQL, etc.

In this blog, we’ll focus solely on building the web server — step by step — so you understand exactly what’s happening under the hood.

What is a Web Server?

Let’s bust a myth:

❌ A server isn’t always a giant machine in a datacenter.

✅ A web server is simply a piece of software whose job is to receive requests and send responses.

No matter the language — PHP, .NET, Node.js, Python — the core idea stays the same:

Listen on a port → Process the request → Send a response

You can even build a web server on your local laptop — and that’s exactly what we’ll do.

Node.js vs Bun – JavaScript Runtimes for the Backend

First, What’s a Runtime?

Before comparing Node.js and Bun, let’s answer a basic question:
JavaScript was originally made to run in browsers... so how are we using it to build backend servers?

The answer: JavaScript Runtime Environments — tools that allow JavaScript to run outside the browser (on your computer or a server).

These runtimes provide:

Access to the file system
Ability to create servers
Tools for running scripts, installing packages, and much more

Let’s explore the two most popular runtimes today: Node.js and Bun.

Node.js – The Veteran in the Game

eleased: 2009
Used by: Netflix, PayPal, LinkedIn, Walmart, and many more
Built with: C++, JavaScript, and Google Chrome’s V8 engine

Key Features:

Event-Driven, Non-blocking I/O:
Perfect for handling thousands of concurrent network requests — great for APIs, real-time apps (like chats), and more.
Massive Package Ecosystem (npm):
With over 2 million packages, npm is the largest open-source library in the world. You can find ready-made solutions for almost anything.
Cross-Platform:
Runs on Windows, macOS, and Linux with minimal setup.
Active Community & Support:
Tons of tutorials, Stack Overflow answers, and official documentation to help you.
Used in Production Everywhere:
Node.js powers high-scale applications like Discord, Trello, and Uber.

️ Typical Use Cases:

RESTful APIs
Real-time apps (WebSocket servers)
Microservices
Backend for web/mobile apps
CLI tools

Bun – The New Speedster

Released: 2022 (very recent)
Built with: Zig programming language (known for speed and safety)
Engine: JavaScriptCore (used by Safari)

Key Features:

Blazing Fast Performance:
Up to 3x faster than Node.js in some benchmarks. Ideal for high-performance apps.
All-in-One Toolchain:
Bun replaces several tools in the Node ecosystem with one unified solution:

Feature Bun Replaces

HTTP Server express, http

Package Manager npm, yarn

Task Runner npm scripts, gulp

Bundler webpack, esbuild, vite

Test Runner jest, mocha
Built-in TypeScript Support:
No need to set up TypeScript compilers or configs — it just works.
Minimal Setup:
Fewer configuration files, faster install times, and cleaner development workflow.

	Feature	Bun Replaces
	HTTP Server	`express`, `http`
	Package Manager	`npm`, `yarn`
	Task Runner	`npm scripts`, `gulp`
	Bundler	`webpack`, `esbuild`, `vite`
	Test Runner	`jest`, `mocha`

Things to Keep in Mind:

Still new and evolving — some npm packages might not work perfectly yet
Smaller community compared to Node.js
Best suited for newer projects or experimental builds

Our Approach in This Blog

You don’t need to master Node.js or Bun before starting.

We'll focus on Node.js throughout this series for three reasons:

It’s more stable and widely adopted
Most job roles still prefer Node.js experience
Tons of beginner resources are available for support

But you’re always welcome to explore Bun once you’re comfortable!

Installing Node.js and Bun

Both are available for all major OS:

Node.js: https://nodejs.org
Bun: https://bun.sh

For this lesson, we’ll start by using Node.js to create a basic HTTP server.

Let's Build: Your First Web Server in Node.js

Here’s how you get started:

Step-by-Step Setup

Create a project folder

mkdir backend && cd backend
mkdir 01-web-server && cd 01-web-server

Open it in VS Code
Create a file
```
server-node.js
```
Check Node Installation
```
node -v
```

Code: Creating an HTTP Server in Node.js

// 1. Import Node's built-in http module
const http = require("http");

// 2. Define hostname and port
const hostname = "127.0.0.1";
const port = 3000;

// 3. Create a server instance with a callback
const server = http.createServer((req, res) => {
  res.statusCode = 200; // OK
  res.setHeader("Content-Type", "text/plain");
  res.end("Hello from your first Node server!");
});

// 4. Start listening
server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

This creates a local server that responds to every request with "Hello from your first Node server!"

How This Works – A Breakdown

Let’s write our first backend program — a simple HTTP server using Node’s built-in http module.

// 1. Import Node's built-in http module
const http = require("http");

http is a core module in Node.js — no need to install it.
It provides functions to create a web server and handle HTTP requests/responses.

// 2. Define hostname and port
const hostname = "127.0.0.1";
const port = 3000;

hostname: 127.0.0.1 refers to localhost — your own computer.
port: A unique number used by the server to listen for requests (3000 is a common dev port).

// 3. Create a server instance with a callback
const server = http.createServer((req, res) => {
  res.statusCode = 200; // OK
  res.setHeader("Content-Type", "text/plain");
  res.end("Hello from your first Node server!");
});

http.createServer() creates the server.
It takes a callback with two parameters:

req = the incoming request from the client
res = the response you send back

Inside the callback:

res.statusCode = 200 → means “OK” (request was successful)
res.setHeader() → tells the client that the content is plain text
res.end() → finalizes the response and sends it to the client

// 4. Start listening
server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

.listen() starts the server on the specified hostname and port.
The callback logs a message to the terminal once the server is up and running.

Output:

When you run the file with:

node server-node.js

Open your browser or send a request from postman and go to:
http://127.0.0.1:3000
You’ll see:

Hello from your first Node server!

Boom! You've just created your first backend server.

Why This Matters

Understanding this flow sets the foundation for everything you’ll build later:

Express.js
REST APIs
File serving
Auth systems
Database communication

If you know how to create and manage a server at this raw level, the frameworks and tools later on will make a lot more sense.

Summary – What We Covered

Topic	Key Takeaways
Backend Architecture	Client → Server → Database (we focused on server)
Web Server	Just software that serves responses
JavaScript Runtime	Node.js and Bun allow JS to run outside the browser
Code	You wrote your first HTTP server in Node.js
Philosophy	Learn by building, no need to “master” Node first

What's Next?

In the upcoming parts of this blog series

we will see handling different routes and HTTP methods in this Node server.
We’ll explore how to write web servers using Bun
Try to understand the need of these frameworks

Until then, play around with the Node.js server.
Try changing the port, printing the request URL, or sending different responses. Try sending a request from http://127.0.0.1:3000/login or http://127.0.0.1:3000/hello or any other url.

Try to find out what’s wrong with our present server XD !!!!!!!

Coder Legion - Recent posts tagged bun

Building Web Servers with Node.js and Bun – A Backend Developer’s First Step

Welcome Back to the Backend Development Series!

⚠️ The Problem With Our First Server

What Is Routing?

What You’ll Learn in This Blog

️ Building a Smarter Web Server in Node.js (Vanilla Style)

Step 1: Create a File

Step 2: Add This Code

What’s Happening Here?

req.url

if...else if...else

▶️ How to Run It

Why This Matters

Rebuilding the Same Server with Bun

Step 1: Create a File

Step 2: Add This Code

What’s Going On Here?

✅ import { serve } from "bun"

✅ fetch(req)

✅ new URL(req.url)

✅ return new Response(...)

What You Just Did

▶️ How to Run It

Key Learnings – Node.js vs Bun Syntax Comparison

⚠️ The Problem: Code Reusability & Scalability

The Solution: Use a Framework

What’s Next?

Getting Started with Backend Development: Web Servers, Node.js, and Bun Explained

What's the Prerequisite?

Understanding Backend Architecture

Client-Server Architecture

What is a Web Server?

Node.js vs Bun – JavaScript Runtimes for the Backend

First, What’s a Runtime?

Node.js – The Veteran in the Game

Key Features:

️ Typical Use Cases:

Bun – The New Speedster

Key Features:

Things to Keep in Mind:

Our Approach in This Blog

Installing Node.js and Bun

Let's Build: Your First Web Server in Node.js

Step-by-Step Setup

Code: Creating an HTTP Server in Node.js

How This Works – A Breakdown

Output:

Why This Matters

Summary – What We Covered

What's Next?

`req.url`

`if...else if...else`

✅ `import { serve } from "bun"`

✅ `fetch(req)`

✅ `new URL(req.url)`

✅ `return new Response(...)`

What’s `Next`?