Prefer visuals and a step-by-step explanation? Watch the video above.

Prefer reading? This article covers the same idea from scratch in a few minutes.

So we'll build it from the ground up:

Express
  ↓
Routes & HTTP methods
  ↓
Callback functions
  ↓
Route handlers
  ↓
Chaining functions
  ↓
next()
  ↓
Middleware
  ↓
Multiple middleware
  ↓
Error handling
  ↓
Types of middleware

A lot of tutorials make middleware sound more complicated than it really is.

We'll keep it simple and understand what's actually happening.

Start with a simple Express app

const express = require("express");

const app = express();

app.get("/", (req, res) => {
  res.send("Hello World");
});

app.listen(3000);

The basic flow is:

Client
  ↓
Request
  ↓
Express
  ↓
Route Handler
  ↓
Response

The function passed to app.get() is called the route handler.

What is a callback?

Look at this:

app.get("/users", (req, res) => {
  res.send("Users");
});

We are passing a function to another function.

Express receives that function and calls it later when a matching request arrives.

That function is a callback.

In this example, the callback is also the route handler.

Express has different HTTP methods

You will commonly see:

app.get("/users", handler);
app.post("/users", handler);
app.put("/users", handler);
app.patch("/users", handler);
app.delete("/users", handler);

The method tells Express what kind of request should match.

There is also app.use() and app.all().

What is app.use()?

app.use(handler);

app.use() is not tied to one specific HTTP method.

You can also give it a path:

app.use("/api", handler);

This can apply to requests such as:

GET    /api/users
POST   /api/users
GET    /api/products
DELETE /api/products/123

The path is optional for app.use():

app.use((req, res, next) => {
  console.log("Request received");
  next();
});

Without a path, it can run for requests that reach this point in the application.

At this stage, we are only looking at the syntax and matching behavior. We'll call these functions middleware later.

What is app.all()?

You might not even know that app.all() exists.

app.all("/users", handler);

app.all() matches the /users route for all HTTP methods.

For example:

GET    /users
POST   /users
PUT    /users
PATCH  /users
DELETE /users

app.use() vs app.all()

They can both work regardless of the HTTP method, but their path matching is different.

app.all("/users")
→ route-path matching

app.use("/users")
→ prefix / mount-path matching

For example:

app.all("/users")

✅ GET    /users
✅ POST   /users
✅ DELETE /users

❌ GET    /users/123

But:

app.use("/users")

✅ GET    /users
✅ GET    /users/123
✅ POST   /users/123
✅ DELETE /users/123

So the simple mental model is:

app.all()
→ all methods for one route

app.use()
→ all methods for a path prefix

What about the route path and callback?

For app.get(), app.post(), app.put(), app.patch(), app.delete(), and app.all(), the route path is part of the route definition:

app.get("/users", handler);
app.post("/users", handler);
app.all("/users", handler);

You can pass the callback directly:

app.get("/users", (req, res) => {
  res.send("Users");
});

You don't have to create a named function first.

With app.use(), the path can be omitted:

app.use((req, res, next) => {
  next();
});

So:

app.get("/users", handler)
→ GET /users

app.all("/users", handler)
→ all methods for /users

app.use("/users", handler)
→ all methods for /users and matching sub-paths

app.use(handler)
→ no path restriction

Route paths can use more than simple strings

A route path does not always have to be a plain string.

Express also supports regular expressions as route paths:

app.get(/\/users\/\d+/, (req, res) => {
  res.send("User route");
});

This can match paths such as:

/users/123
/users/456

The idea is still the same:

Request path
    ↓
Path pattern
    ↓
Match?
    ↓
Run handler

Express 5 still supports regular expressions as paths.

What changed in Express 5 is the older string-pattern syntax. Some special pattern characters that worked inside string paths in older Express versions no longer work the same way.

When you need a real regular expression, use an explicit RegExp such as:

/\/users\/\d+/

You don't need to remember this unless you actually need complex route matching.

A route can have multiple functions

A route can receive more than one function:

app.get(
  "/users",
  function firstFunction(req, res) {
    console.log("First function");
  },
  function secondFunction(req, res) {
    console.log("Second function");
  }
);

We now have multiple functions in the same route.

But the first function does not automatically move to the second one.

That's where next() comes in.

Where does next() come from?

app.get("/users", (req, res, next) => {
  console.log("First function");
  next();
});

When Express calls this function, it provides:

req
res
next

req is the request.

res is the response.

next is a function Express gives us to continue to the next matching function.

Now we can write:

app.get(
  "/users",
  (req, res, next) => {
    console.log("First function");
    next();
  },
  (req, res) => {
    res.send("Users");
  }
);

The flow is:

Request
   ↓
Function 1
   ↓
next()
   ↓
Function 2
   ↓
Response

The next function can be another function in the same app.get():

app.get(
  "/users",
  first,
  second,
  third
);

Or next() can continue into another matching handler or middleware registered separately:

app.use(first);

app.get("/users", second);

So the request moves through the matching functions Express has registered.

Multiple functions can also be passed as an array

Express also lets you pass callback functions as an array:

app.get("/users", [
  firstFunction,
  secondFunction,
  thirdFunction
]);

You can also mix arrays and individual functions:

app.get(
  "/users",
  firstFunction,
  [secondFunction, thirdFunction],
  fourthFunction
);

They are still treated as a chain of functions.

An array is useful when you want to group related functions and reuse them:

const userChecks = [
  checkUser,
  validateUser,
  loadUser
];

app.get("/users", userChecks, getUsers);

So these are different ways of giving Express a chain of functions:

Function 1, Function 2, Function 3

or

[Function 1, Function 2, Function 3]

or

Function 1, [Function 2, Function 3], Function 4

What is middleware?

Now the definition is simple:

Middleware is a function that participates in the request-response cycle.

For example:

app.use((req, res, next) => {
  console.log(req.method, req.url);
  next();
});

There is nothing special about app.use() itself.

A middleware-style function can also be used with a route:

app.get("/users", (req, res, next) => {
  console.log("Checking request");
  next();
});

We generally use app.use() when we want something to apply across methods and matching paths.

The function is the middleware.

app.use() is simply one way to register it.

What can middleware do?

Middleware can:

• run some logic

• read or modify req

• read or modify res

• send a response

• call next() to continue

For example:

app.use((req, res, next) => {
  console.log(req.method, req.url);
  next();
});

The flow is:

Middleware
    ↓
Do some work
    ↓
next()
    ↓
Continue

Middleware is commonly placed before the routes that need it, so the request can pass through it first.

Middleware can stop the request

Middleware does not always have to call next().

app.use((req, res, next) => {
  if (!req.headers.authorization) {
    return res.status(401).send("Unauthorized");
  }

  next();
});

The flow is:

             Request
                ↓
           Middleware
           /        \
      Reject       Continue
        ↓             ↓
    Response        next()
                      ↓
                 Next function

So middleware can either continue the chain or end the request.

Middleware can pass data forward

The same request object moves through the chain.

That means one middleware can attach data to it:

app.use((req, res, next) => {
  req.user = {
    id: 123
  };

  next();
});

app.get("/profile", (req, res) => {
  res.json(req.user);
});

The flow is:

Request
   ↓
Middleware
   ↓
req.user = ...
   ↓
Route Handler
   ↓
Response

This is one of the main reasons middleware is useful.

Multiple middleware functions

You can chain several functions:

app.get(
  "/profile",
  checkLogin,
  checkProfile,
  loadProfile,
  showProfile
);

Request
   ↓
checkLogin
   ↓
checkProfile
   ↓
loadProfile
   ↓
showProfile
   ↓
Response

Each function can do some work and call next().

Middleware vs route handler

They use the same basic function mechanism, but usually have different jobs.

Route handler

Usually finishes the request:

app.get("/users", (req, res) => {
  res.json(users);
});

Middleware

Usually does some work before the final handler:

app.use((req, res, next) => {
  console.log("Request received");
  next();
});

But middleware can also send the response and end the request.

The difference is mainly about the function's role in the request flow.

What exactly does next() do?

next() means:

Continue this current request with the next matching function.

It does not mean "next request."

Also, next() does not stop the current JavaScript function automatically.

Consider:

app.get(
  "/users",
  (req, res, next) => {
    next();

    res.send("Hello");
  },
  (req, res) => {
    res.send("Users");
  }
);

When next() is called, Express continues to the next function.

That function sends:

Users

The earlier function has not automatically stopped.

After the next function finishes, JavaScript can continue from where the earlier function called next().

So this line can then run:

res.send("Hello");

Now we are trying to send another response for the same request.

That can cause an error such as:

Can't set headers after they are sent

In simple words, headers are small pieces of information sent with the response, such as content type and other response details.

Once the response has already been sent, you cannot send another response for the same request.

This is also why understanding JavaScript functions, the call stack, and execution flow is useful when working with Express.

If you want to understand this part deeply, callbacks, execution context, the call stack, and how V8 runs JavaScript are worth learning separately.

Error-handling middleware

First, what is error-handling middleware?

It is simply a middleware function whose job is to handle errors.

Express identifies it by its four-argument signature:

(err, req, res, next)

For example:

app.use((err, req, res, next) => {
  res.status(500).json({
    error: err.message
  });
});

An error can be passed with:

next(err);

When Express receives an error, it skips the remaining normal middleware and route handlers and looks for the next error-handling middleware.

For example:

Middleware 1
    ↓
Middleware 2
    ↓
   Error
    ↓
next(err)
    ↓
Skip normal handlers
    ↓
Nearest matching error handler
    ↓
Response

If there are several error handlers, Express uses the next matching error handler in the chain.

If that error handler calls next(err), Express continues looking for another error handler.

If your application has no custom error handler that handles the error, Express has a built-in error handler.

Types of Express middleware

Express commonly describes five types.

1. Application-level middleware

This is middleware attached to the main Express app.

You can register it with app.use():

app.use(logger);

Or with a specific HTTP method:

app.get("/users", checkLogin);

For example:

app.use((req, res, next) => {
  console.log("Request received");
  next();
});

This runs for requests that reach this point in the app.

You can also limit it to a path:

app.use("/api", logger);

Now it applies to requests under /api.

Another example:

app.use(express.json());
app.use("/api", checkLogin);

Think of application-level middleware as:

Middleware attached to the main app

2. Router-level middleware

Router-level middleware works the same way, but it is attached to an express.Router() instead of the main app.

For example:

const router = express.Router();

router.use(checkLogin);

router.get("/profile", showProfile);
router.get("/orders", showOrders);

Here, checkLogin applies to the routes inside that router.

You can also attach it to one route:

router.get("/profile", checkLogin, showProfile);

And mount the router on the main app:

app.use("/account", router);

Now the structure looks like:

app
  ↓
/account router
  ↓
router middleware
  ↓
router route

Router-level middleware is useful when you want to keep related routes and their middleware together.

3. Error-handling middleware

This middleware handles errors:

app.use((err, req, res, next) => {
  res.status(500).send("Something went wrong");
});

Another simple example:

app.use((err, req, res, next) => {
  console.error(err.message);
  next(err);
});

You can also have more than one:

app.use(logError);
app.use(sendErrorResponse);

4. Built-in middleware

These are middleware functions provided by Express.

For example:

app.use(express.json());

This parses JSON request bodies.

Another:

app.use(express.urlencoded({ extended: true }));

And:

app.use(express.static("public"));

This serves static files.

Think:

Built into Express
→ use it directly

5. Third-party middleware

These come from external npm packages.

For example:

const cors = require("cors");

app.use(cors());

Another common example:

const cookieParser = require("cookie-parser");

app.use(cookieParser());

And:

const morgan = require("morgan");

app.use(morgan("dev"));

Think:

Third-party package
→ install it
→ register it
→ use its middleware

You don't need to memorize these five categories.

The important thing is understanding what middleware is and where it can be attached.

The mental model

Everything comes back to this:

Client
  ↓
Request
  ↓
Middleware
  ↓
Middleware
  ↓
Route Handler
  ↓
Response
  ↓
Client

At any step, a function can:

Do some work
    ↓
Modify req/res
    ↓
Send a response

or

next()
    ↓
Continue the chain

or

next(err)
    ↓
Go to error handling

Once you understand routes, callbacks, chained functions, next(), and the request-response flow, middleware becomes a very small concept.

app.use() is one way to register middleware.

next() moves the current request forward.

And middleware is simply the name we give to functions that participate in that request-processing flow.

What happens when you click on a link?

What is the Internet? How does the Web work?

What is client, server, https, domain name system server, etc.? What do we mean by these jargons?

By the end of this article, you will be well versed in the Internet and all its related technology!

What is Internet?

The Internet is a global network of interconnections of computers. It's like a big spider web where each node of the web is like a computer. The Internet, in simple words, is the connection of all the computers in the world. As the computers are interconnected due to this network "Internet,“ they can talk with each other, communicate, and exchange information.

For example, a person in India using his computer can communicate with another computer used by the person in the USA. They can send emails, pictures, and pdf’s to each other. Thanks to the Internet.

Let us understand the Internet in depth with a diagram.

We understood the main work and meaning of the internet - linking computers and communicating with one another. Exchanging information was the main goal of the Internet.

We understood the concept of the Internet, but still, how does a website stored on the server get loaded in your browser just by typing the URL? How does all this happen? Is it magic? Let's understand the inner engineering of this masterpiece, Internet.

When we type URL (fancy name for link) in the browser, the website gets loaded. So this happens due to the client server architecture and its request response model.

Client - Server Architecture(Request Response Model)

So when client(user/device/browser) enters the URL(link) in the browser, a request is made to the server(a machine that contains your website code and runs 24×7). The server(machine containing your website code) then sends a response back with the website code, and this code is rendered by the browser, and you can see the website.

So in simple terms, the client (user) sends a request to the server (the machine containing the website’s code), and the server in return sends the website's code as a response. This website's code is rendered by the browser, and successfully you can see the website and use it.

What is HTTP?

HTTP stands for HyperText Transfer Protocol. Http is basically a set of rules used to transfer the web document containing hyperlinks (plain old links).

So some rules are to be followed if we need to send a web/text document containing links; this is the primary role of HTTP. So while communicating between systems, we follow the HTTP.

Let's go a bit more in depth about client-server communication.

As shown in the above diagram, the client-server communication is not that simple; it's quite complicated. Let's try to understand in simple layman's terms. The client sends a request to the server, and the server, in return, sends a response as files containing the website’s code, but how does the browser (client) know the address of the server where the website is stored? We only know the name of the website (domain name), for example, google.com, but how, by just typing google.com in the browser, does it reach the server, as the client (browser) does not know the address of the server where the website is stored?

This address of the server is found by translating the domain name (name of the website, for example, google.com) into its corresponding IP address, and this IP address is the address of the server where the website's code is stored. This translation of domain to IP address is done by the Domain Name System Server (DNS Server). In the above diagram, you can see how complex the process of translating a domain to an IP is; this process of translating a domain to an IP is called DNS Resolution. It's a bit complex; it involves communicating with root servers and their top-level domains, then the authoritative name server, and so on, until the IP address of the website is not returned by the DNS to the browser.

Once we get the IP address of the server, we then use HTTP to communicate with the server, and then the request-response cycle continues…

Conclusion

The Internet is a global network of interconnected computers. Using the Internet, computers communicate with each other.

There’s a lot in terms of loading a URL; the client sends a request to the server, and the server sends a response giving the website’s code. The client uses HTTPS to communicate. For the client to communicate with the server using HTTPS, first it needs to know the IP address of the server. We get the IP address of the server from the DNS server; it does DNS resolution and gives us the IP address of the server, and then we use HTTP to communicate with the server(and then the request response cycle goes on).

1) What is a Computer?

A machine that processes information, stores data, performs calculations and run programs.

(Computer ek aisi machine hai jo data process karti hai, calculations karti hai, aur programs chalati hai.)

2) What is the Internet?

A massive network connecting millions of computers worldwide, allowing them to exchange information. It’s like a big spider web, where each computer is a node connected by threads.

(Internet duniya bhar ke computers ko connect karta hai, jaise ek invisible spider web. Har computer ek node hai jo information exchange kar sakta hai.)

3) What is HTTP?

It stands for HyperText Transfer Protocol. Before understanding HTTP, let’s first understand the last word in it “Protocol”.

Protocol: A set of rules that computers follow to communicate. It’s like a language they all agree on.
(Protocol woh rules ka set hai jo computers ko ek doosre se baat karne ke liye follow karna padta hai.)

HTTP (HyperText Transfer Protocol): A protocol that allows computers to share information, such as web pages. It’s what happens when you type a URL and hit Enter, your browser follows HTTP rules to fetch the web page from the server.
(HTTP ek protocol hai jo web pages ko server se browser tak lane ka kaam karta hai.)

4) What is the Request-Response Cycle/Model?

It is a system where your computer (client/browser/user agent) makes a request, and another computer (server/backend) responds.
So, you make a request, and in return, you get a response.

(Request-response model ek system hai jisme ek computer kuch maangta hai (request), aur doosra computer uska jawab deta hai (response).)

5) What are HTTP Headers?

HTTP headers are extra pieces of information sent with a request or response, similar to how your name or return address appears on an envelope.

(HTTP headers wo extra details hai jo request-response ke saath bheji jati hai.)

6) What is a Stateless Protocol? (Why is HTTP a Stateless Protocol?)

A stateless protocol (like HTTP) doesn't retain information about previous interactions. It's like meeting a new person each time, no memory of past conversations.

In simple words it doesnot remember the memory of previous requests.

(HTTP stateless hai, matlab use kuch yaad nahi rehta. HTTP ko pehle ki baatein yaad nahi rehti)

7) What are Sessions, Cookies, Cache, Local Storage and how do they differ from each other?

1. Session: Stores temporary data during your visit and ends when you close the browser.
   Example: Keeps you logged in while you're on the site.

   (Temporary data jo aapke visit ke dauran store hota hai aur browser band karne par khatam ho jata hai.
   Udharan: Jab tak aap site pe hote hain, aap login rehte hain.)

2. Cookie:
   Stores small data (small piece of info) to remember things across visits, like login details or preferences (they are key-value pairs).
   Example: Remembers your language choice next time you visit.

   (Chhoti data (key-value pairs) jo aapki preferences ya login details ko store karte hain, jo future visits pe yaad rehti hain.
   Udharan: Aapki language choice yaad rehti hai jab aap dobara visit karte hain.)

3. Cache:
   Saves website files (like images) to load pages faster on future visits (speeds up the website).
   Example: Images load quicker because they're saved locally.

   (Website ke files (jaise images) ko save karta hai, jisse agle visit pe website jaldi load ho.
   Udharan: Images jaldi load hoti hain kyunki wo locally save hoti hain.)

4. Local Storage:
   Saves larger data on your device for a longer time, even after the browser is closed.
   Example: Remembers your website preferences (e.g., theme) across visits.

   (Lambe samay tak data save karta hai, browser band hone ke baad bhi.
   Udharan: Aapke website preferences (jaise theme) yaad rakhta hai har visit pe.)

Key Differences:

• Session: Temporary data that lasts until the browser is closed.

  (Session: Temporary data jo browser band hone tak rehta hai.)

• Cookie: Small data stored across sessions, sent to the server with requests.

  (Cookie: Chhoti data jo sessions ke beech store hoti hai aur server ko bheji jaati hai.)

• Cache: Stores resources to speed up loading times on future visits.

  (Cache: Website ke resources ko store karta hai taaki future visits pe website jaldi load ho.)

• Local Storage: Stores larger data persistently on the client-side, even after the browser is closed.

  (Local Storage: Zyada data store karta hai jo client side pe rehta hai aur browser band hone ke baad bhi rehta hai.)

8) What is the difference between HTTP and HTTPS?

HTTP: A protocol that sends data in plain text, not secure.
(HTTP mein data secure nahi hota.)

HTTPS: A secure version of HTTP that uses encryption to protect data, along with features like compression (reducing data size) and multiplexing (sending multiple files at once) to speed up communication.
(HTTPS mein data encrypted hota hai, aur compression aur multiplexing ka use karke data transfer ko fast banaya jata hai.)

9) What are SSL and TLS?

SSL (Secure Sockets Layer) was introduced in 1994 to secure web traffic by encrypting data.

TLS (Transport Layer Security) is a more secure version of SSL, and it's now widely used to protect data in modern web communication.

(SSL pehle tha, lekin ab TLS use hota hai, jo zyada secure hai aur certificates batate hain taki website trust karne layak hoo.)

10) What is IP?

IP (Internet Protocol) is a unique address assigned to every device connected to the internet. It identifies devices and helps them communicate over a network.

(IP ek unique address hota hai jo har device ko internet par milta hai, jisse wo devices ek dusre se communicate kar sakte hain.)

11) What is Domain?

Human-friendly names for websites (e.g., google.com). The human-readable form of an IP address.

(Domain ek website ka naam hota hai.)

12) What is URL?

The complete address of a web page.

13) What is DNS?

A system that translates domain names into IP addresses (like a phonebook).

(DNS domain ko IP address mein convert karta hai, taki browser ko pata chale ki data kahan se lana hai.)

14) What is Client?

The computer or browser that asks for something.

(Client request karta hai.)

15) What is Server?

The computer that provides the requested information.

(Server reply deta hai.)

16) What is Frontend?

The visible part of a website.

(Frontend wo hota hai jo user dekhta hai.)

17) What is Backend?

The hidden part that processes requests.

(Backend wo hota hai jo behind-the-scenes kaam karta hai.)

18) What is TCP?

TCP (Transmission Control Protocol) is a reliable, connection-oriented protocol that ensures data is delivered correctly and in order.

(TCP reliable hai, data sahi order mein aur bina errors ke bhejta hai.)

19) What is UDP?

UDP (User Datagram Protocol) is a fast, connectionless protocol that sends data without guaranteeing delivery or order.

(UDP fast hai, lekin delivery aur order ki guarantee nahi deta.)

20) What is FTP?

FTP (File Transfer Protocol) is used to transfer files between computers using TCP for reliable communication.

(FTP files transfer karne ke liye hota hai, aur TCP ko use karta hai data ko reliably bhejne ke liye.)

21) What is the difference between TCP, UDP and FTP?

• TCP: Reliable, slower, ensures correct delivery.

• UDP: Unreliable, faster, no guarantee.

• FTP: File transfer protocol using TCP for reliable transfers.

(TCP reliable hai, UDP fast hai aur FTP file transfer ke liye use hota hai.)

22) What is Payload?

Payload refers to the actual data being sent in a network packet, excluding the headers and metadata.

(Payload wo asli data hota hai jo network pe send kiya jata hai, headers aur extra information ke bina.)

23) What is VOIP?

VOIP (Voice over Internet Protocol) allows voice communication over the internet instead of traditional phone lines.

(VOIP internet ke through voice calls karne ka tareeka hai, jo traditional phone lines ki jagah use hota hai.)

24) What are ports and how many are there in a computer?

Ports are virtual channels that allow services or apps to communicate over a network, like doors on your computer. Each service uses a specific port (e.g., port 80 for browsing). (Ports wo virtual channels hote hain jo services ya apps ko network par connect karte hain, jaise doors jo computer ko services se connect karte hain.)

There are 65,535 ports in a computer. (Computer mein 65,535 ports hote hain.)

25) What is Throttling?

Throttling is the practice of limiting the amount of data or requests a user can send to a service or server to prevent overload. (Throttling ka matlab hai data ya requests ki limit laga dena taaki service ya server overload na ho.)

It is used to manage server load and ensure fair usage. (Yeh server ka load manage karne aur fair usage ensure karne ke liye use hota hai.)