Creating a basic HTTP server in Node.js - Visual Walkthrough

Concept Flow - Creating a basic HTTP server

Start Node.js

↓

Import http module

↓

Create server with request handler

↓

Server listens on port

↓

Client sends request

↓

Server handles request

↓

Server sends response

↓

Client receives response

↓

End

This flow shows how Node.js starts, creates an HTTP server, listens for requests, handles them, and sends responses back to clients.

Execution Sample

Node.js

import http from 'http';

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World');
});

server.listen(3000);

This code creates a simple HTTP server that responds with 'Hello World' to every request on port 3000.

Execution Table

Step	Action	Evaluation	Result
1	Import http module	http module loaded	http object available
2	Create server with request handler	Function passed to createServer	server object created
3	Start server listening on port 3000	server.listen(3000)	Server waits for requests
4	Client sends request	Request received by server	Request object (req) created
5	Server handles request	Execute handler function	Set statusCode=200, set header
6	Server sends response	res.end('Hello World')	Response sent to client
7	Client receives response	Response with 'Hello World'	Client displays 'Hello World'
8	No more requests	Server keeps running	Waiting for next request

💡 Server runs continuously until manually stopped; no exit in normal flow

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	After Step 6	Final
http	undefined	http module object	http module object	http module object	http module object	http module object
server	undefined	server object created	server listening	server listening	server listening	server listening
req	undefined	undefined	undefined	request object	request object	undefined
res	undefined	undefined	undefined	response object	response sent	undefined

Key Moments - 3 Insights

Why does the server keep running after sending a response?

Because server.listen keeps the Node.js process alive waiting for more requests, as shown in execution_table step 8.

What happens if we don't call res.end()?

The response never finishes, so the client waits forever. Step 6 shows res.end sends the response and ends it.

Why do we set headers before ending the response?

Headers must be sent before the body. Step 5 sets headers, then step 6 ends response with body.

Visual Quiz - 3 Questions

Look at the execution table, what is the statusCode set to in step 5?

A 200

B 404

C 500

D Undefined

💡 Hint

Check step 5 in execution_table where server handles request and sets statusCode

At which step does the server start listening for requests?

A Step 5

B Step 2

C Step 3

D Step 7

💡 Hint

Look at execution_table step 3 where server.listen is called

If we remove res.end(), what happens to the client response?

A Client receives 'Hello World' anyway

B Client waits forever for response to finish

C Server crashes immediately

D Response is sent but with empty body

💡 Hint

Refer to key_moments explanation about importance of res.end() after step 6

Concept Snapshot

Create HTTP server with http.createServer(handler).
Handler gets request and response objects.
Set statusCode and headers on response.
Call res.end() to send response body.
Start server with server.listen(port).
Server runs continuously until stopped.

Full Transcript

This lesson shows how to create a basic HTTP server in Node.js. First, we import the http module. Then, we create a server using http.createServer and provide a function that handles requests and responses. Inside this function, we set the response status code to 200, set the Content-Type header to text/plain, and end the response with 'Hello World'. We start the server listening on port 3000. When a client sends a request, the server runs the handler, sends the response, and the client receives 'Hello World'. The server keeps running waiting for more requests until manually stopped.

Practice

1. What does the http.createServer() function do in Node.js?

easy

A. It compiles JavaScript code into machine code.

B. It creates a database connection for storing data.

C. It creates a server that listens for HTTP requests and sends responses.

D. It formats JSON data for sending over the network.

Solution

1. Step 1: Understand the purpose of http.createServer()

   This function sets up a server that waits for HTTP requests from clients like browsers.

2. Step 2: Identify what the server does

   The server uses a function to handle incoming requests and send back responses, enabling communication over the web.

3. Final Answer:

   It creates a server that listens for HTTP requests and sends responses. -> Option C

4. Quick Check:

   HTTP server creation = It creates a server that listens for HTTP requests and sends responses. [OK]

Hint: Remember: createServer sets up the web server [OK]

Common Mistakes:

• Confusing server creation with database connection
• Thinking it compiles code
• Mixing up data formatting with server setup

2. Which of the following is the correct way to start a Node.js HTTP server on port 3000?

easy

A. http.listen(3000);

B. server.listen(3000);

C. server.start(3000);

D. server.run(3000);

Solution

1. Step 1: Identify the method to start the server

   The correct method to make the server listen on a port is listen().

2. Step 2: Match the method with the server object

   Calling server.listen(3000); starts the server on port 3000.

3. Final Answer:

   server.listen(3000); -> Option B

4. Quick Check:

   Start server with listen() = server.listen(3000); [OK]

Hint: Use listen() to start the server on a port [OK]

Common Mistakes:

• Using non-existent methods like start() or run()
• Calling listen() on http instead of server
• Confusing server methods with other modules

3. What will the following Node.js code output when accessed via a browser?

const http = require('http');
const server = http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World');
});
server.listen(4000);

medium

A. Hello World

B. Error: server.listen is not a function

C. 404 Not Found

D. Hello

Solution

1. Step 1: Analyze the server response setup

   The server sets the HTTP status to 200 (OK) and content type to plain text, then sends 'Hello World' as the response body.

2. Step 2: Understand what the browser receives

   When accessed, the browser will display the exact string 'Hello World' from the server response.

3. Final Answer:

   Hello World -> Option A

4. Quick Check:

   Response text = Hello World [OK]

Hint: Check res.end() content for output text [OK]

Common Mistakes:

• Expecting an error due to incorrect method
• Confusing status codes with output text
• Assuming partial output without reading res.end()

4. Identify the error in this Node.js HTTP server code:

const http = require('http');
const server = http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.write('Welcome');
  res.end();
});
server.listen(8080)
console.log('Server running on port 8080');

medium

A. Incorrect Content-Type header value

B. Using res.write() without res.end() causes error

C. Missing semicolon after server.listen(8080)

D. No error; code runs correctly and serves 'Welcome'

Solution

1. Step 1: Check syntax and method usage

   The code correctly calls res.write() followed by res.end(), which is valid to send response data.

2. Step 2: Verify headers and server start

   The Content-Type is valid as 'text/html', and server.listen(8080) starts the server properly. Missing semicolons are optional in JavaScript.

3. Final Answer:

   No error; code runs correctly and serves 'Welcome' -> Option D

4. Quick Check:

   Valid server code = No error; code runs correctly and serves 'Welcome' [OK]

Hint: res.write() + res.end() is valid to send response [OK]

Common Mistakes:

• Thinking missing semicolons cause errors
• Believing res.write() must be avoided
• Assuming wrong Content-Type causes failure

5. You want to create a Node.js HTTP server that responds with JSON data {"status":"ok"} and sets the correct header. Which code snippet correctly does this?

hard

A. const server = http.createServer((req, res) => {
res.writeHead(200, {'Content-Type': 'application/json'});
res.end(JSON.stringify({status: 'ok'}));
});

B. const server = http.createServer((req, res) => {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('{"status":"ok"}');
});

C. const server = http.createServer((req, res) => {
res.writeHead(404, {'Content-Type': 'application/json'});
res.end(JSON.stringify({status: 'ok'}));
});

D. const server = http.createServer((req, res) => {
res.writeHead(200);
res.end({status: 'ok'});
});

Solution

1. Step 1: Set correct Content-Type header for JSON

   The header must be 'application/json' to tell the client the response is JSON data.

2. Step 2: Send JSON string as response body

   Use JSON.stringify() to convert the object to a JSON string before sending with res.end().

3. Final Answer:

   Code snippet with application/json header and JSON.stringify() -> Option A

4. Quick Check:

   JSON header + stringified data = const server = http.createServer((req, res) => { res.writeHead(200, {'Content-Type': 'application/json'}); res.end(JSON.stringify({status: 'ok'})); }); [OK]

Hint: Use application/json header and JSON.stringify() [OK]

Common Mistakes:

• Sending object directly without stringifying
• Using wrong Content-Type header
• Sending JSON string with text/plain header
• Using 404 status instead of 200