Effective use of middleware in express.js: practical approaches
Tags: express, javascript, beginners, node
Published: 2023-09-03 04:19:43

## 1. Introduction

Hello there!
Welcome to our exploration of the fascinating world of Express.js middleware!
In this guide, we're taking a deep dive into middleware and its pivotal role within Express.js applications.

### 1.1 Definition of Express.js middleware

Middleware acts as a bridge between the incoming client requests and the outgoing server responses.

It's like a helpful intermediary that steps in to process, modify, or augment requests as they move through your application.

  

Imagine you're hosting a party where each guest enters through a hallway.

Now, think of middleware as the courteous host who greets each guest, checks their invitations, offers them appetizers, and ensures they head to the right room.

Similarly, middleware in Express.js helps streamline your application flow, enhancing its performance, security, and functionality.

  

Consider an authentication middleware that ensures users are logged in before they can access certain routes.  
This middleware intercepts the request, checks if the user is authenticated, and either lets them proceed or redirects them to the login page.  
  
Here's a basic code snippet that illustrates this concept:

```javascript
const authenticationMiddleware = (req, res, next) => {
  if (req.isAuthenticated()) {
    // User is authenticated, allow them to proceed
    next();
  } else {
    // User is not authenticated, redirect to login page
    res.redirect('/login');
  }
};
```

This simple example showcases how middleware can add an extra layer of control to your application's behavior.

  

### 1.2 Significance of middleware in web applications


Middleware is like the behind-the-scenes conductor of a grand orchestra, orchestrating the flow of data and requests in your Express.js application. It plays a crucial role in keeping your code organized, maintainable, and scalable.

Instead of cramming every feature into one monolithic codebase, middleware lets you compartmentalize different tasks, making your application more manageable and elegant.

As we dive deeper into this guide, we'll not only define middleware but also uncover its significance in crafting efficient and feature-rich Express.js applications.

Let's start by resolving how middleware functions within the request-response cycle, shedding light on its essential role.

Ready to explore? Let's move on to the next section!  
  

## 2. The Role of Middleware in Express.js

### 2.1 Explanation of middleware in the request-response cycle

Let's unwrap the concept of middleware further by understanding how it operates within the rhythm of the request-response cycle in Express.js.

Visualize this cycle as hosting a grand party, where the guests (requests) arrive and engage in lively conversations, and you, as the host (middleware), ensure everything runs smoothly.

The beauty of middleware is that it allows you to greet guests, offer them refreshments, and guide them to different sections of the party based on their needs.

Imagine your guests arriving at a magnificent mansion (your application).

As they walk through the door, you, the charming host (middleware), warmly greet them, verify their invitations, and maybe even hand them a sparkling drink.

Then, depending on their preferences, you guide them to the dance floor, the lounge, or the buffet.


### 2.2 Handling requests and responses using middleware

Now, let's break down how middleware handles requests and responses, using the party metaphor:

**Request Middleware**: Think of this as the vigilant bouncer stationed at the entrance. Just like a bouncer checks guest invitations and ensures the party's security, request middleware processes incoming data, adds crucial headers, and carries out security checks. For instance, you can use middleware to log incoming requests, keeping a watchful eye on your application's activity.

```javascript
const requestLoggerMiddleware = (req, res, next) => {
  console.log(`Incoming request to ${req.path} from ${req.ip}`);
  next();
};
app.use(requestLoggerMiddleware);
```

**Response Middleware**: Imagine this as the decorator who adds finishing touches before guests experience a new area of the party. Response middleware polishes the response data, adds final headers, or carries out any necessary clean-up tasks. Comparable to how a decorator enhances the ambiance, response middleware improves the user experience.

```javascript
const responseDecoratorMiddleware = (req, res, next) => {
  res.setHeader('X-App-Version', '1.0.0');
  next();
};
app.use(responseDecoratorMiddleware);
```

By maintaining this metaphor, middleware continues to play the role of a gracious host who ensures a seamless and enjoyable experience for both guests (requests) and the ambiance (responses).
  
## 3. Built-in Middleware in Express.js

### 3.1 Overview of common built-in middleware
As our party analogy continues, let's explore the various amenities and facilities available within our grand mansion (Express.js application).

Just as a lavish party requires multiple stations for guests to enjoy, an Express.js application employs built-in middleware to handle different aspects of the party.

### 3.2 Examples and use cases for built-in middleware
Now, let's delve into some specific built-in middleware stations within our party mansion, understanding their roles and how they enhance the overall experience:

#### 3.2.1 `express.json()` and `express.urlencoded()`

Think of these as the gourmet chefs stationed at the buffet table.

They prepare and serve delectable dishes (data) that guests can savor.

These middleware stations handle parsing incoming data from requests—be it JSON or form data.

They ensure that the guests (requests) get to enjoy the buffet without any hassle.

```javascript
app.use(express.json()); // For parsing JSON data
app.use(express.urlencoded({ extended: true })); // For parsing URL-encoded form data
```

#### 3.2.2 `express.static()`

Imagine this as the art gallery within our mansion.

This middleware station showcases the visually appealing assets of our party—images, stylesheets, and JavaScript files.

It serves these static files directly to guests (clients), allowing them to appreciate the artistic elements that enrich their experience.

```javascript
app.use(express.static('public')); // Serving static assets from the 'public' folder
```

#### 3.2.3 `express.Router()`

Consider this as the signage that guides guests to different sections of the mansion. `express.Router()` acts as a modular middleware, allowing you to organize routes into separate files.

This keeps your codebase neat and tidy, just like well-placed signs that ensure guests never lose their way.

```javascript
const adminRouter = express.Router();
adminRouter.get('/dashboard', (req, res) => {
  // Admin dashboard route logic
});
app.use('/admin', adminRouter); // Mounting the adminRouter middleware
```

By associating built-in middleware with our party mansion, we're creating an environment where guests (requests) can enjoy various facilities without encountering any confusion.

Now that we've toured the built-in amenities, let's step into the realm of crafting custom middleware to tailor the party experience even further.


## 4. Crafting Custom Middleware  

### 4.1 Creating custom middleware functions

Continuing with our party analogy, imagine you want to introduce a unique station in the mansion—a room where guests can personalize their experience.

Similarly, in Express.js, crafting custom middleware lets you add tailored features to your application.

You're the architect here, building a distinct experience for your guests (requests).

### 4.2 Anatomy of a middleware function

Think of a custom middleware function as the host who introduces a unique party game for the guests. It follows a specific structure: accepting the `request`, `response`, and `next` parameters. The `next` parameter is the baton you pass to ensure the party game moves forward smoothly.

Here's a detailed example: Let's say you want to create a middleware that logs the timestamp of each incoming request.

```javascript
const timestampLoggerMiddleware = (req, res, next) => {
  const now = new Date();
  console.log(`[${now.toISOString()}] Incoming request to ${req.path}`);
  next(); // Pass control to the next middleware
};
```

### 4.3 Adding custom middleware to an Express.js app

Adding custom middleware is like inviting a talented performer to entertain your party guests.

You register your middleware function using `app.use()`, ensuring it's available for every incoming request.

```javascript
app.use(timestampLoggerMiddleware);
```

### 4.4 Examples showcasing the utility of custom middleware

Imagine a photo booth station within your mansion—a perfect example of custom middleware. Let's create middleware that adds a personalized signature to the response of each guest (request).

```javascript
const personalizeSignatureMiddleware = (req, res, next) => {
  res.locals.signature = "Party Enthusiast";
  next();
};
app.use(personalizeSignatureMiddleware);
```

Now, every time a guest (request) receives a response, they'll also get a personalized signature.

This showcases how custom middleware empowers you to tailor the experience for your guests (requests), leaving a lasting impression.

With custom middleware, you're not just throwing a party; you're crafting an unforgettable experience. Next, we'll learn how to manage the flow of middleware and explore its impact on the overall party atmosphere—your Express.js application.  

## 5. Managing Middleware Chains and Execution Order

### 5.1 Organizing middleware functions in chains

Let's envision our mansion party as a sequence of elegantly themed rooms, each offering a unique experience.

Just like our rooms, Express.js applications arrange middleware functions in organized chains.

These chains are like a curated journey where guests (requests) traverse through various rooms, each showcasing a distinct facet of the party.

Imagine you're hosting a mansion party with a luxurious lounge, a dance floor, and a game room.

These rooms symbolize different middleware functions.

By organizing them thoughtfully, you ensure guests have a delightful and seamless transition, much like a well-designed sequence of experiences.

Here's how you might structure middleware chains for different routes in your Express.js app:

```javascript
app.use('/public', publicMiddlewareChain); // Middleware chain for public routes
app.use('/private', privateMiddlewareChain); // Middleware chain for private routes
```

### 5.2 Order of middleware execution

Just as you'd carefully orchestrate the sequence of party activities, the order in which middleware functions are executed matters in Express.js.

Middleware functions are processed in the order they're added using `app.use()`.

Think of it as arranging guests' activities to ensure they enjoy the party to the fullest.

Consider a scenario: You have a middleware that logs guest preferences and another that provides personalized recommendations.

The logging middleware should come before the recommendation middleware to gather data before making suggestions.

Here's how the order of middleware execution impacts the outcome:

```javascript
app.use(logMiddleware); // Log guest preferences
app.use(recommendationMiddleware); // Provide personalized recommendations
```

### 5.3 Scenarios highlighting the importance of middleware order

Imagine you're hosting two events in different rooms: a formal dinner in one and a live concert in another.

You decide to have an attire-checking station. If you place the attire-checking middleware after guests enter the formal dinner, it won't be effective, and guests might not meet the dress code.

Similarly, in Express.js, understanding middleware order prevents issues like serving static assets before authentication.  

Here's how to handle middleware order to ensure efficient execution:

```javascript
app.use(checkAttireMiddleware); // Check guest attire before entering
app.use(formalDinnerMiddleware); // Formal dinner event
```

By meticulously arranging middleware functions, you create a symphony of experiences for your guests (requests). Just as orchestrating activities enhances a grand party, managing middleware order elevates the user experience and ensures a seamless flow through your Express.js application.

Wrapping up, here’s a simple Express.js server example for you to visualize chaining organization:  
  
```javascript
const express = require('express');
const app = express();

// Middleware for logging requests
const logMiddleware = (req, res, next) => {
  console.log(`[${new Date().toLocaleTimeString()}] Incoming request to ${req.path}`);
  next();
};

// Middleware for personalized recommendations
const recommendationMiddleware = (req, res, next) => {
  const recommendations = ['Try the new cocktail!', 'Check out the dance floor!', 'Join the trivia game!'];
  res.locals.recommendation = recommendations[Math.floor(Math.random() * recommendations.length)];
  next();
};

// Middleware for checking guest attire
const checkAttireMiddleware = (req, res, next) => {
  if (req.query.attire === 'formal') {
    next();
  } else {
    res.send("Sorry, only guests in formal attire can enter the formal dinner.");
  }
};

// Applying middleware chains to different routes
app.use('/public', logMiddleware, recommendationMiddleware);
app.use('/private', logMiddleware, checkAttireMiddleware, recommendationMiddleware);

app.get('/', (req, res) => {
  res.send('Welcome to the mansion party! Feel free to explore.');
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});
```  
  
In this example, we've created an Express.js server with three middleware functions: logMiddleware, recommendationMiddleware, and checkAttireMiddleware. These middlewares are organized in chains for different routes: `/public` and `/private`.

The order of middleware execution and their roles can be observed as you interact with the different routes.

This simple server showcases how middleware functions are organized, executed, and contribute to the overall flow of your Express.js application.

  
  
## 6. Effective Error Handling with Middleware

Errors are an inevitable part of any software application, much like unexpected mishaps during a grand party.

### 6.1 Implementing error-handling middleware

Let's imagine our mansion party in full swing, with guests enjoying different rooms and activities. Just as a party may encounter unforeseen mishaps, errors can occur in your Express.js application. Handling these errors gracefully is crucial to maintaining a pleasant experience.

Consider our host role as the guardian of the party's smooth flow. Similarly, error-handling middleware acts as the party planner who quickly resolves issues without disrupting the festivities. To implement error handling, you need to create a middleware that handles errors and gracefully guides guests (requests) through unexpected situations.

Here's how you might craft an error-handling middleware:

```javascript
const errorHandlerMiddleware = (err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send("Oops! Something went wrong.");
};
```

### 6.2 Differentiating standard and error-handling middleware

In Express.js, middleware functions serve various purposes, and it's crucial to differentiate between standard middleware and error-handling middleware.

Standard middleware is designed to enhance the user experience and carry out tasks such as parsing request data, handling authentication, and serving static assets.

On the other hand, error-handling middleware is dedicated to addressing errors that might occur during the request-response cycle.

It's specifically designed to gracefully manage unexpected situations and prevent them from disrupting the application's functionality.

Imagine you're hosting a grand masquerade ball. While most rooms are designed for enjoyment, there's an emergency station where staff address unexpected issues. Similarly, in Express.js, standard middleware focuses on enhancing the experience, while error-handling middleware specifically handles errors.

Just as a dedicated emergency station ensures the safety of the event, error-handling middleware safeguards your application's stability. This differentiation ensures that even when unexpected errors arise, your guests (requests) are well taken care of.

```javascript
app.use(logMiddleware);
app.use(recommendationMiddleware);
app.use(errorHandlerMiddleware); // Error-handling middleware comes last
```

### 6.3 Best practices for error handling and responses

Just as impeccable service and clear communication ensure guest satisfaction at a party, effective error handling in your application is a reflection of professionalism. When it comes to error handling and responses, consider the following best practices:
  
**Logging Errors:** In the event of an error, log relevant information using console.error() or a logging library. This provides valuable insights for debugging and improving your application.

**HTTP Status Codes:** Assign appropriate HTTP status codes to your responses. For example, use res.status(404).send("Resource not found") for a resource that doesn't exist. Consistent status codes help clients understand the nature of the error.

**Detailed Error Messages:** Provide detailed error messages in responses to aid both developers and users in understanding what went wrong. You can use JSON responses for this purpose.  

In our mansion party, impeccable service is a priority. Similarly, when handling errors in Express.js, maintaining professionalism and providing clear responses is essential. Error-handling middleware can log errors, provide appropriate HTTP status codes, and send detailed error messages.

By following this practices, you assure guests (requests) that you're on top of the situation, just like our party planner swiftly addressing unexpected hiccups.
  
## 7. Strengthening Security with Authentication and Authorization Middleware

Security is paramount in any event, and our Express.js application's security is no different.

In this section, we're putting on our bouncer hats to ensure only authorized guests are allowed to enjoy the party.

Just as bouncers verify guests' identities and grant access, authentication and authorization middleware verify users' permissions within our application.

### 7.1 Creating authentication middleware for user sessions

Authentication is like checking the guest list before granting entry to the mansion party.
In Express.js, authentication middleware verifies users' identities based on credentials.
This process ensures only authorized users gain access to protected areas of the application.

Here's how you might implement a basic authentication middleware:

```javascript
const authenticationMiddleware = (req, res, next) => {
  if (req.session && req.session.user) {
    // User is authenticated, let him enter
    next();
  } else {
    res.status(401).send("Unauthorized access");
  }
};
```

### 7.2 Authorization middleware for route access control

Authorization is akin to granting different access levels based on guests' invitations.
Authorization middleware in Express.js controls what specific users can and cannot do within the application.
Just as certain rooms are off-limits to certain guests, authorization middleware limits access to particular routes.

```javascript
const authorizationMiddleware = (req, res, next) => {
  if (req.session && req.session.user && req.session.user.role === 'admin') {
	// User is authorized as an admin
	next();
  } else {
	res.status(403).send("Forbidden access");
  }
};
```

### 7.3 Middleware's contribution to application security

Middleware, including authentication and authorization, acts as our vigilant security personnel throughout the party.

Just as bouncers ensure a safe and enjoyable experience for guests, middleware safeguards our application by preventing unauthorized access and malicious activities.

It's a crucial component in the defense against potential security threats.

  By implementing authentication and authorization middleware, you're fortifying your Express.js application against unauthorized access and ensuring that only authorized users can access specific routes and perform authorized actions.

It's like having a team of trusted bouncers guarding your party's VIP section and ensuring a secure environment for all guests.

## 8. Exploring Third-Party Middleware Modules

As our mansion party continues, we're thrilled to introduce our special VIP guests—third-party middleware modules. These modules bring their own unique talents to the table, just like guest performers at a grand event. Third-party middleware enhances your Express.js application with powerful features, and today, we're focusing on one of the headliners: the `helmet` middleware.  

### 8.1 Introduction to third-party middleware options

Imagine third-party middleware as top-notch entertainers at your event.

They come with their acts, saving you time and effort. Developed by the community, these modules seamlessly enhance your Express.js application. Let's dive into the star of the show: `helmet`.

  

### 8.2 Examples of popular third-party middleware

Let's showcase the superstar `helmet` middleware and how it empowers your application's security.

#### 8.2.1 `helmet` for security enhancement
The `helmet` middleware is like your party's security team, ensuring every corner is safe.

It provides powerful security features by setting essential HTTP headers that mitigate various vulnerabilities and attacks.

**Enhancing Security with `helmet`:**
Just as a vigilant security team monitors guests, `helmet` monitors your application's security. Consider the powerful `Content-Security-Policy` header it adds. This header prevents cross-site scripting (XSS) and other attacks by defining where resources can be loaded from. 

For instance, the following code configures the `script-src` directive:


```javascript
app.use(
  helmet({		
    contentSecurityPolicy: {
	  directives: {
		"script-src": ["'self'", "example.com"],
	  },
	},
  })
);
```

With this code, only scripts from your application and `example.com` are allowed, preventing unauthorized script execution.

**Documentation Link:** [helmet](https://helmetjs.github.io/)


#### 8.2.2 `morgan` for logging

Now, let's shift our focus to another esteemed guest: the morgan middleware.

Think of morgan as the event's official photographer, capturing every intricate detail by logging incoming requests and responses.

**In-Depth Request Logging with `morgan`:**

In the spirit of having a dedicated photographer at your event, morgan diligently logs essential details of each guest's arrival and departure.

This middleware can be tailored to log specific aspects of incoming requests and responses.

For instance, this code snippet captures the request method, URL, status, response time, and more:

```javascript
const morgan = require('morgan');
app.use(morgan(':method :url :status :response-time ms'));
```
With this setup, every log entry offers concise yet informative insights about incoming requests—akin to the photographs that capture memorable moments of your event.

Here’s a more detailed example:

```javascript  
const express = require('express');
const morgan = require('morgan');
const app = express();

// Custom token to log the user's IP address
morgan.token('user-ip', (req) => {
  return req.headers['x-forwarded-for'] || req.connection.remoteAddress;
});

// Creating a custom logging format
const customFormat = ':method :url :status :response-time ms - :user-ip';

// Using the custom logging format with morgan middleware
app.use(morgan(customFormat));

app.get('/', (req, res) => {
  res.send('Hello, Express app with custom logging!');
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});
```

In this extended example, we've introduced a custom token user-ip using morgan.token().

This token captures the user's IP address, whether it's obtained from the x-forwarded-for header or the remote address of the connection.

Then, we've defined a custom logging format named customFormat that includes the :method, :url, :status, :response-time, and the custom :user-ip tokens.

By utilizing this custom logging format, you're creating logs that provide detailed insights into each request's method, URL, status code, response time, and the user's IP address.

This richer information can be incredibly valuable for diagnosing issues, monitoring performance, and gaining a deeper understanding of how your application is being used.

Remember that these examples are meant to be adaptable to your specific needs. By customizing the format and tokens, you can tailor the logging to suit your application's unique requirements.

**Documentation Link:** [morgan](https://github.com/expressjs/morgan)

#### 8.2.3 `cors` for cross-origin request handling

Our final guest is the `cors` middleware, managing interactions with guests from various domains. Just as your party welcomes attendees from diverse backgrounds, `cors` facilitates cross-origin communication by adding necessary headers.  
  
```javascript
const express = require('express');
const cors = require('cors');
const app = express();

// Enable CORS for all routes
app.use(cors());

app.get('/', (req, res) => {
  res.send('Hello, CORS-enabled Express app!');
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});
```

In this example, we've imported the cors middleware and used `app.use(cors())` to enable CORS for all routes. By doing this, your Express app will include the necessary CORS headers in its responses, allowing cross-origin requests from any origin.

This is a basic example, but you can customize the behavior of cors by passing in options. For instance, you can specify which origins are allowed, what headers are permitted, and more. The cors middleware is a powerful tool for handling cross-origin requests securely and efficiently.

By inviting these VIP guests—`helmet`, `morgan`, and `cors`—to your application, you enhance its security, logging capabilities, and cross-origin communication. Similar to how special performers elevate your party's atmosphere, third-party middleware enriches your Express.js application with powerful functionalities.


## 9. Best Practices for Middleware Usage

### 9.1 Maintaining Focused and Single-Purpose Middleware Functions

One of the key principles in developing middleware is to ensure that each middleware function has a clear and single-purpose responsibility. This enhances code organization and maintainability, making it easier to understand and modify the behavior of your application. A focused middleware function accomplishes a specific task without unnecessary complexity.

Consider an authentication middleware. Instead of combining authentication and authorization checks within a single middleware, separate them into two distinct middleware functions. This approach keeps the responsibilities clear and makes it easier to manage each aspect individually.

```javascript
// Authentication middleware
function authenticate(req, res, next) {
  // ... authentication logic ...
  if (authenticated) {
	req.user = authenticatedUser;
	next();
  } else {
	res.status(401).send('Unauthorized');
  }
}

// Authorization middleware
function authorizeAdmin(req, res, next) {
  if (req.user && req.user.isAdmin) {
	next();
  } else {
	res.status(403).send('Access forbidden');
  }
}

app.get('/admin', authenticate, authorizeAdmin, (req, res) => {
  res.send('Welcome to the admin panel');
});
```

### 9.2 Judicious Use of Middleware for Code Readability

While middleware can enhance code organization, excessive use can lead to overly complex pipelines. Carefully consider whether a middleware is essential for every route. Avoid using middleware for small, isolated tasks that can be handled inline. Prioritize using middleware for repetitive, cross-cutting concerns.

Suppose you have a route that requires sending an email notification. Instead of creating a separate middleware for this single task, handle it inline within the route handler for clarity.

```javascript
app.post('/new-order', (req, res) => {
  // ... process order ...
  // Send email notification
  sendEmailNotification(req.user.email, 'Order placed');
  res.send('Order placed successfully');
});
```

### 9.3 Tips for Testing and Debugging Middleware

Testing and debugging middleware is crucial to ensure that your application functions as expected. Isolate middleware testing and use tools like `chai`, `mocha`, or `jest` to write comprehensive tests for various scenarios. Use debugging tools to troubleshoot middleware behavior and catch errors.

When testing a middleware, consider using a mock request and response to simulate different scenarios and assertions.

```javascript
const chai = require('chai');
const chaiHttp = require('chai-http');
chai.use(chaiHttp);

// Mocking middleware
const mockMiddleware = (req, res, next) => {
  req.customProperty = 'Hello, Middleware!';
  next();
};

describe('Middleware Tests', () => {
  it('should add custom property to request', (done) => {
	const app = express();
	app.use(mockMiddleware);

	app.get('/', (req, res) => {
	  res.json({ message: req.customProperty });
	});

	chai.request(app)
	.get('/')
	.end((err, res) => {
	  chai.expect(res.body.message).to.equal('Hello, Middleware!');
	  done();
	});
  });
});
```

By adhering to these best practices, your middleware usage becomes more effective, promotes maintainable code, and ensures reliable application behavior. 
Remember that flexibility and adaptability are key; tailor these practices to your application's specific requirements.  
  
  
## 10. Conclusion
  
Congratulations! You've finished a comprehensive journey through the world of Express.js middleware.

We've explored the fundamental concepts, practical applications, and best practices that empower you to build robust and efficient web applications.
As you've seen, middleware plays a crucial role in enhancing your app's functionality, security, and maintainability.
By mastering middleware, you've gained the ability to seamlessly integrate various functionalities into your application's request-response cycle.

Whether you're handling data parsing, logging, authentication, security, or any custom functionality, middleware empowers you to customize your app's behavior at different stages.
As you continue refining your skills and honing your expertise, remember to maintain the principles of focused and single-purpose middleware functions.
Keep your code readable by judiciously choosing when to use middleware and when to handle tasks inline.
Testing and debugging middleware ensures your app's reliability and stability.

 
**Thank you** for investing your time in this exploration of Express.js middleware.

Remember that this is just the beginning of your journey.

Keep building, experimenting, and exploring the ever-evolving world of web development.

  

### Stay Connected
If you enjoyed this article and want to explore more about web development, feel free to connect with me on various platforms:

[dev.to](https://dev.to/leandro_nnz)

[hackernoon.com](https://hackernoon.com/u/leandronnz)

[hashnode.com](https://leandronnz.hashnode.dev)

[twitter.com](https://twitter.com/digpollution)

Your feedback and questions are always welcome.
Keep learning, coding, and creating amazing web applications.

**Happy coding!**