Forem: Khaled Md Saifullah

The Ultimate Guide to MongoDB Aggregation Pipeline | Concepts, Use Cases and Real Code Examples

Khaled Md Saifullah — Fri, 27 Feb 2026 13:28:46 +0000

MongoDB is one of the most popular NoSQL databases used in modern backend development, especially for applications that demand flexibility and high performance.

One of its most powerful features is the Aggregation Pipeline, a data processing framework that allows you to transform, filter, group and analyze documents in a highly efficient way.

In this article, you will learn:

What the MongoDB Pipeline is
Why it is necessary
Where we use aggregation pipelines
Real example with Node.js
Advantages & disadvantages

What Is Aggregation Pipeline in MongoDB?

The Aggregation Pipeline is a framework in MongoDB that processes data in multiple stages.

Each stage takes the input from the previous stage, transforms it and passes it to the next stage similar to a production pipeline.

Example

db.students.aggregate([
  { $match: { age: { $gt: 18 } } },
  { $project: { name: 1, marks: 1 } },
  { $sort: { marks: -1 } }
])

This above MongoDB aggregation first filters the students whose age is greater than 18, then selects only the name and marks fields from those documents and finally sorts the results in descending order of marks.

Why Is Aggregation Pipeline Necessary?

Without aggregation, we would need to write long, complex application logic or multiple database queries to analyze or transform data.

The aggregation pipeline helps because

It reduces server load: We process data inside the database, not in your app.
It improves performance: MongoDB’s aggregation is highly optimized with indexes & query engines.
It simplifies data transformation: Sorting, grouping, filtering, joining, array operations all in one pipeline.
It supports analytics: We can generate real-time insights without exporting data.

Where Do We Use MongoDB Aggregation Pipelines?

Aggregation makes MongoDB behave like a lightweight analytical engine. Aggregation pipelines are used whenever we need structured or analytical data from unstructured documents.

Common Use Cases

User analytics (active users, retention, cohorts)
E-commerce (sales reports, top products, revenue calculation)
Social media apps (post trends, engagement insights)
Education platforms (ranking students, performance stats)
Financial apps (transactions summary, patterns)
Log analysis (count, group, filter logs)
Joining collections ($lookup)

Mini Project: Aggregation Pipeline with Node.js

Below is a simple API built with Node.js, Express and MongoDB using ES6 modules.

Folder Structure

pipeline-project/
 ├── src/
 │   ├── config/
 │   │   └── db.js
 │   │
 │   ├── routes/
 │   │   └── student.routes.js
 │   │
 │   ├── controllers/
 │   │   └── student.controller.js
 │   │
 │   ├── index.js
 │
 ├── package.json
 ├── .env
 ├── .gitignore

Install Dependencies

npm init -y
npm install express mongoose dotenv

Create .env File

PORT=8000
MONGO_URI=mongodb://127.0.0.1:27017/schoolDB

Sample Student Collection (Insert Data in the MongoDB Locally)

db.students.insertMany([
  { name: "John", age: 18, marks: 80, subjects: ["Math", "Physics"] },
  { name: "Joshep", age: 19, marks: 65, subjects: ["Math", "Chemistry"] },
  { name: "Jane", age: 17, marks: 90, subjects: ["Biology", "Math"] }
])

Database Connection

Create the db.js file and add the code below:

import mongoose from "mongoose";
import dotenv from "dotenv";
dotenv.config();

export const connectDB = async () => {
  try {
    await mongoose.connect(process.env.MONGO_URI, {
      dbName: "schoolDB",
    });

    console.log("Database Connected Successfully");
  } catch (error) {
    console.error("Database Connection Error:", error.message);
    process.exit(1);
  }
};

Create Student Model

First we need the blueprint of the student model. For that we need to create the model in the Student.js file

import mongoose from "mongoose";

const studentSchema = new mongoose.Schema({
  name: { type: String, required: true },
  age: Number,
  marks: Number,
  subjects: [String]
});

export default mongoose.model("Student", studentSchema);

Aggregation Logic

Now, we need to write the aggregation logic in the controller(student.controller.js) file

import Student from "../models/Student.js";

export const getTopStudents = async (req, res) => {
  try {
    const pipeline = [
      { $sort: { marks: -1 } },
      { $limit: 2 },
      { $project: { _id: 0, name: 1, marks: 1 } }
    ];

    const result = await Student.aggregate(pipeline);

    res.status(200).json({
      success: true,
      data: result
    });

  } catch (error) {
    res.status(500).json({
      success: false,
      message: "Something went wrong",
      error: error.message,
    });
  }
};

Routes

At this step you need to mention all the routes in the following file student.routes.js

import express from "express";
import { getTopStudents } from "../controllers/student.controller.js";

const router = express.Router();

router.get("/top-students", getTopStudents);

export default router;

Main server file

Connect everything with the main file (index.js).

import express from "express";
import dotenv from "dotenv";
import { connectDB } from "./config/db.js";
import studentRoutes from "./routes/student.routes.js";

dotenv.config();

const app = express();
app.use(express.json());

// Connect database
connectDB();

// Routes
app.use("/api", studentRoutes);

app.listen(process.env.PORT, () => {
  console.log(`Server running on http://localhost:${process.env.PORT}`);
});

Test the API

curl -X GET http://localhost:8000/api/top-students

Conclusion

The MongoDB Aggregation Pipeline is one of the most powerful features of MongoDB giving developers the ability to filter, transform, group, join and analyze data directly inside the database. Instead of writing heavy logic in Node.js, you can let MongoDB perform the hard work efficiently.

In this mini project, I have explored:

How aggregation pipelines work
Why they are important
A real Node.js and Mongoose setup

With this foundation, we can now build:

Analytics dashboards
Reporting systems
E-commerce revenue charts
Social media insights
Real-time data transformations

Aggregation pipelines turn MongoDB into a powerful data-processing engine and once we master it, we will unlock a new level of backend capabilities.

Horizontal Scaling Strategies for Node.js Applications

Khaled Md Saifullah — Tue, 24 Feb 2026 15:43:59 +0000

Modern applications demand high availability, low latency, and the ability to handle unpredictable spikes in traffic. As your Node.js application grows, vertical scaling (adding more CPU/RAM) eventually hits a hard limit. That is where horizontal scaling becomes essential.

With the help of real-world examples, I will examine advanced horizontal scaling techniques for Node.js in this article, such as clustering, load balancing, containerization, distributed caching, message queues, microservices architecture and more.

Why Horizontal Scaling?

Horizontal scaling means adding more instances/servers of your application instead of relying on a single powerful machine.

Benefits

Higher fault tolerance
Better performance under heavy load
Zero downtime deployments
Can scale infinitely with microservices and distributed systems

When Do We Need It?

CPU spikes during peak hours
Real-time applications (chat, gaming, live updates)
API latency increases
You are preparing for enterprise level traffic

Node.js Clustering (Multi-Core Utilization)

By default, a Node.js process runs on a single core, even on an 8-core CPU. Clustering allows us to fork multiple workers to utilize all CPU cores.

import cluster from "cluster";
import os from "os";
import express from "express";

if (cluster.isPrimary) {
  const cpus = os.cpus().length;
  console.log(`Master PID: ${process.pid}`);

  for (let i = 0; i < cpus; i++) cluster.fork();

  cluster.on("exit", (worker) => {
    console.log(`Worker ${worker.process.pid} died. Restarting...`);
    cluster.fork();
  });
} else {
  const app = express();
  app.get("/", (req, res) => res.send(`Handled by ${process.pid}`));
  app.listen(3000);
}

When to use clustering

CPU heavy tasks
API endpoints under heavy load
When no distributed system is needed yet

Clustering only scales within one machine. For real horizontal scaling, we combine clustering with load balancing.

Load Balancing Node.js Apps

Load balancers distribute traffic across multiple servers to improve reliability and performance.

NGINX Load Balancer
Most production apps use Nginx to balance traffic.
Nginx example configuration:

upstream backend {
    server 127.0.0.1:3001;
    server 127.0.0.1:3002;
    server 127.0.0.1:3003;
}

server {
    listen 80;

    location / {
        proxy_pass http://backend;
    }
}

PM2 Load Balancer
PM2 automatically runs cluster mode:

pm2 start server.js -i max

Cloud Load Balancers

AWS ALB
Google Cloud Load Balancer
DigitalOcean Load Balancer

Container Based Horizontal Scaling (Docker with Kubernetes)

Using Docker ensures consistent deployments across environments.

Dockerizing the Node.js App

FROM node:alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["npm", "start"]

Horizontal Scaling using Docker Compose

services:
  api:
    image: my-api
    deploy:
      replicas: 5

Scaling on Kubernetes

kubectl scale deployment api --replicas=10

This gives us dynamic auto scaling based on CPU, memory or custom metrics.

Distributed Caching with Redis

A major performance bottleneck happens when multiple instances hit the same database.

To solve this, use a shared Redis cache so every server uses the same cached data.

Redis Caching in Node.js

import express from "express";
import Redis from "ioredis";

const redis = new Redis();
const app = express();

app.get("/user/:id", async (req, res) => {
  const cached = await redis.get(req.params.id);
  if (cached) return res.json(JSON.parse(cached));

  const user = await getUserFromDB(req.params.id); 
  await redis.set(req.params.id, JSON.stringify(user), "EX", 3600);

  res.json(user);
});

Advantages

Reduces database load
Speeds up repeated requests
Ensures consistent data across multiple servers

Message Queues for Async Processing (RabbitMQ / BullMQ)

To prevent overload, heavy tasks should run asynchronously instead of handling them inside API calls.

Architecture

Client → API → Queue → Worker Servers → Database

Use Cases

Email sending
Video processing
Billing workflows
Notifications
High traffic event ingestion

Example using BullMQ

import { Queue } from "bullmq";
const queue = new Queue("emailQueue");

queue.add("sendEmail", { userId: 123 });

Stateless Application Architecture

To scale horizontally, your app must be stateless.

Don't

Storing sessions in memory
Storing cache locally

Redis for sessions
S3 or Cloud storage for files
Database for persistence

Once our app becomes stateless, we can run unlimited instances behind a load balancer.

Microservices & Event-Driven Architecture

A monolith becomes hard to scale when:

development teams grow
endpoints depend on heavy business logic
features need to scale independently

Microservices allow independent scaling of components.

Example Microservice Breakdown

Auth Service  →  10 replicas
Payments      →  3 replicas
Notifications →  8 replicas
Core API      →  15 replicas

Microservices communicate through:

REST
gRPC
Message bus (BullMQ, RabbitMQ)
Event streams

Real-Time Applications Scaling

WebSockets do not naturally scale because clients stick to a single server.

Here, solution would be Redis Pub/Sub Adapter

npm install @socket.io/redis-adapter ioredis

import { createAdapter } from "@socket.io/redis-adapter";
import Redis from "ioredis";

const pub = new Redis();
const sub = new Redis();

io.adapter(createAdapter(pub, sub));

Database Sharding & Replication

As traffic grows, the database becomes the largest bottleneck.

Replication

Reads are distributed across replica servers

Good for read heavy apps

Sharding

Cuts the database into multiple partitions

Good for massive datasets

Conclusion

Horizontal scaling is essential for any Node.js application that needs to handle growing traffic and demand. By combining techniques like clustering, load balancing, distributed caching, Docker/Kubernetes scaling, message queues and stateless architecture, we create a system that is faster, more resilient and ready for real world production workloads.

These strategies ensure our app can scale across multiple servers without downtime, maintain consistent performance and support future growth. Mastering them is a key step toward building high availability, enterprise grade Node.js applications.

Redis Explained: What It Is, Why Developers Use It and the Problems It Solves

Khaled Md Saifullah — Sat, 31 Jan 2026 16:31:52 +0000

Introduction

If you have heard developers talk about Redis, you might wonder why it is such a big deal. Redis shows up in backend development, caching, real-time systems, session storage, queues and even gaming leaderboards.

This blog breaks down:

What Redis is
Why developers use Redis
What problems it solves
Real examples where Redis makes your app faster and better

Let’s dive in.....!

What Is Redis?

Redis is an open-source, in-memory data store often used as:

a cache
a database
a message broker

Redis stores data in RAM, not on disk, which makes it super fast often completing operations in under a millisecond.

Key Features

In-memory storage (Very Fast)
Supports many data types: strings, lists, sets, hashes, streams, sorted sets
Built-in replication and persistence options
Pub/Sub messaging
Widely used for caching and real-time apps

Why Do We Use Redis?

We use Redis mainly because it reduces load, improves speed and handles real-time data extremely well.

Redis makes your application much faster

Fetching data from a traditional database (like PostgreSQL or MongoDB) takes time. Redis stores data in memory → instant reads and writes.

Redis reduces database load

Instead of hitting your database over and over, you cache common data in Redis.

Redis helps build real-time features

Live chat
Notifications
Leaderboards
Real-time analytics

Redis powers background queues

Tools like BullMQ, Celery, Sidekiq and RQ all use Redis as a job manager.

What Problems Does Redis Solve?

Problem 1: Slow database queries

Redis Solution: Cache frequent data → faster responses

Problem 2: High traffic overload crashes databases

Redis Solution: Offload heavy reads → improve stability

Problem 3: Need for real-time communication

Redis Solution: Pub/Sub → instant messaging/notifications

Problem 4: Need for queues & background workers

Redis Solution: Redis lists/streams → simple and scalable job queues

Problem 5: Need to store short-term data (sessions, tokens)

Redis Solution: TTL support → auto-expiring keys

Real life Example: Using Redis as a Cache

Imagine your application shows a list of trending posts.

Without Redis

Every user request → hits database
Database becomes slow under heavy traffic
Higher costs on scaling the database

With Redis

You store trending posts in Redis:

const redis = require("redis");
const client = redis.createClient();

async function getTrendingPosts() {
  const cacheData = await client.get("trending_posts");

  if (cacheData) {
    return JSON.parse(cacheData);
  }

  const result = await fetchFromDatabase();

  await client.setEx("trending_posts", 300, JSON.stringify(result));

  return result;
}

Result

Faster response time
Lower database cost
Smooth performance even during high traffic

Where Is Redis Commonly Used?

Web apps (session store, caching)
Microservices (queues, shared state)
Gaming (leaderboards, matchmaking)
Real-time dashboards
Chat apps
E-commerce platforms (carts, inventory)
APIs handling huge traffic

Basically, if speed matters, Redis helps.

Summary

Redis is powerful because it solves performance and scaling problems that modern apps face. It is fast, flexible and works well with almost any technology stack.

In short

Redis is an in-memory data store
It makes apps significantly faster
It reduces stress on databases
Perfect for caching, real-time apps, queues and more

If you are building anything that needs speed, reliability, or real-time features, Redis is worth learning.

Final Thoughts

Redis is one of the most developer friendly tools available today. Whether you are building a small project or scaling a big one, Redis can dramatically improve performance.

Backend Security for Express.js (With Nginx + VPS)

Khaled Md Saifullah — Mon, 12 Jan 2026 05:47:11 +0000

Securing an Express.js backend is not just about adding a few middlewares. Real-world security is a layered system: application controls, reverse proxy protection and server level hardening.

This guide is a practical security blueprint for deploying Express.js APIs on a VPS with Nginx in front covering beginner to production grade controls.

Threat Model
Why Backend Security is Critical
Security Baseline
Project Setup
Application Layer Security
- Security Headers
- CORS Strategy
- Authentication & Authorization
- Input Validation & Sanitization
- Rate Limiting
- Request Size Limits
- Logging & Audit
- Secrets & Environment Security
Reverse Proxy Layer (Nginx)
- TLS (HTTPS)
- Nginx Rate Limiting
- Basic Bot/Scanner Reduction
- Recommended Security Headers at Nginx
VPS Setup (Server Level)
- SSH Hardening
- Firewall (UFW)
- Fail2ban
- Automatic Security Updates
Deployment Checklist

Threat Model

A typical public backend is targeted by:

Brute force login attempts
API abuse / scraping
Credential stuffing
Injection attacks
Misconfigured CORS
Token theft
Vulnerability scanners
Reverse-proxy bypass (direct port access)
Server compromise via weak SSH

The goal is to reduce risk using multiple independent layers.

Why Backend Security is Critical

Unlike static websites any applications expose APIs that interact directly with databases and user data. These APIs are a prime target for the attackers.

Threat	Impact
NoSQL Injection	Database compromise
Credential Stuffing	Account takeover
JWT Theft	Full user impersonation
CSRF	Unauthorized actions
XSS	Token and session leakage
API Abuse	Server and payment exploitation

Security Baseline

Minimum production requirements

HTTPS enforced
Strong authentication strategy (JWT or sessions)
Strict CORS
Server-side validation
Rate limiting
Centralized logging
Nginx reverse-proxy protection
Firewall + SSH hardening
Fail2ban + automatic security patches

Project Setup

Install required dependencies

npm i express helmet cors express-rate-limit cookie-parser compression
npm i zod pino pino-http
npm i dotenv

Application Layer Security

1) Security Headers

Use helmet to apply safe defaults.

import helmet from "helmet";

app.use(helmet());

Note: For APIs, avoid over configuring CSP unless you serve web pages too.

2) CORS Strategy

Never use * origins in production, if you rely on cookies or credentials.

import cors from "cors";

const allowedOrigins = [
  "https://your-frontend.com",
  "https://www.your-frontend.com",
];

app.use(cors({
  origin: function (origin, cb) {
    if (!origin) return cb(null, true);
    if (allowedOrigins.includes(origin)) return cb(null, true);
    return cb(new Error("CORS blocked"), false);
  },
  credentials: true,
  methods: ["GET", "POST", "PUT", "PATCH", "DELETE"],
  allowedHeaders: ["Content-Type", "Authorization"]
}));

3) Authentication & Authorization

Authentication proves identity
Authorization ensures access control

Best practice

short lived access tokens
rotate refresh tokens
role-based checks for admin routes

Example authorization guard:

export function requireRole(...roles) {
  return (req, res, next) => {
    if (!req.user || !roles.includes(req.user.role)) {
      return res.status(403).json({ status: false, message: "Forbidden" });
    }
    next();
  };
}

4) Input Validation & Sanitization

Validate every request. Prefer schema validation (Zod).

import { z } from "zod";

const createUserSchema = z.object({
  name: z.string().min(2).max(80),
  email: z.string().email(),
  password: z.string().min(8).max(72),
});

export function validate(schema) {
  return (req, res, next) => {
    const result = schema.safeParse(req.body);
    if (!result.success) {
      return res.status(400).json({
        status: false,
        message: "Validation failed",
        errors: result.error.issues,
      });
    }
    req.body = result.data;
    next();
  };
}

5) Rate Limiting

Use different limits per endpoint category:

global protection (general)
strict for auth endpoints

import rateLimit from "express-rate-limit";

export const globalLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 600,
  standardHeaders: true,
  legacyHeaders: false,
});

export const authLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 20,
  message: { message: "Too many login attempts. Try again later." }
});

app.use(globalLimiter);
app.use("/api/auth", authLimiter);

6) Request Size Limits

Prevent payload abuse.

app.use(express.json({ limit: "200kb" }));
app.use(express.urlencoded({ extended: true, limit: "200kb" }));

7) Logging & Audit

Use structured logging:

import pino from "pino";
import pinoHttp from "pino-http";

const logger = pino({ level: process.env.LOG_LEVEL || "info" });
app.use(pinoHttp({ logger }));

Log:

auth failures
suspicious traffic spikes
rate limit blocks
Never log passwords, tokens or raw secrets

8) Secrets & Environment Security

store secrets in .env (devlopment) and in server environment (prod)
never commit .env
rotate compromised keys immediately

Example

NODE_ENV=production
PORT=3000
JWT_SECRET=YOUR-JWT-SECRET-KEY

Reverse Proxy Layer (Nginx)

Your API should not be exposed directly to the internet. Production setup should be:

Internet → Nginx (443) → Express (127.0.0.1:8000)

1) TLS (HTTPS)

Install Certbot

sudo apt update
sudo apt install nginx certbot python3-certbot-nginx -y

Issue certificate

sudo certbot --nginx -d api.yourdomain.com

Auto renew

sudo systemctl status certbot.timer

2) Nginx Rate Limiting

Add these in /etc/nginx/nginx.conf (inside http { })

limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s;
limit_conn_zone $binary_remote_addr zone=conn_limit:10m;

Example server block

server {
  listen 443 ssl http2;
  server_name api.yourdomain.com;

  # Rate limiting
  limit_req zone=api_limit burst=20 nodelay;
  limit_conn conn_limit 20;

  location / {
    proxy_pass http://localhost:3000;
    proxy_http_version 1.1;

    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;

    # Timeout
    proxy_connect_timeout 10s;
    proxy_send_timeout 30s;
    proxy_read_timeout 30s;
  }
}

3) Basic Bot/Scanner Reduction

Block common junk requests

location = /xmlrpc.php { return 444; }
location = /wp-login.php { return 444; }
location = /.env { return 444; }

4) Recommended Security Headers at Nginx

add_header X-Frame-Options "DENY" always;
add_header X-Content-Type-Options "nosniff" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
add_header Permissions-Policy "geolocation=(), microphone=(), camera=()" always;

VPS Hardening (Server Level)

SSH Hardening

Create a non root user and give sudo permission

adduser deploy
usermod -aG sudo deploy

Disable root login & password auth

# edit on this file
sudo nano /etc/ssh/sshd_config

# set the values below in the config file 
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes

Restart SSH

sudo systemctl restart ssh

Firewall (UFW)

Allow only what you need

sudo ufw allow OpenSSH
sudo ufw allow 80
sudo ufw allow 443
sudo ufw enable
sudo ufw status

Important

Do not expose 8000 publicly
Ensure Express binds to 127.0.0.1

Fail2ban

Install fail2ban

sudo apt install fail2ban -y

Enable basic protection for SSH

sudo systemctl enable --now fail2ban
sudo fail2ban-client status

Automatic Security Updates

sudo apt install unattended-upgrades -y
sudo dpkg-reconfigure unattended-upgrades

Deployment checklist

HTTPS enabled and forced
Express listens only on 127.0.0.1
Nginx proxies traffic to Express
CORS restricted to trusted origins
Input validation for all routes
Rate limiting enabled (app + nginx)
Firewall blocks unused ports
SSH hardened + key-based auth
Fail2ban active
Logs monitored and rotated
Secrets not committed

Final Security Rule

Never trust the frontend
Trust only the backend
Verify everything

Conclusion

Express.js backend security is a discipline rather than a particular configuration or module. Strong application level restrictions, a hardened reverse proxy and a properly locked down server environment are the components of real-world security.

You can greatly limit the attack surface of your API and safeguard your users, data, and business logic from real-world threats by putting in place tiered defenses with Express, Nginx and VPS level security.

For long term production use, a secure backend is not only safer but also more dependable, scalable and trustworthy.

Understanding AWS Load Balancer: The Ultimate Guide to Scalable and Reliable Applications

Khaled Md Saifullah — Sun, 12 Oct 2025 15:37:58 +0000

When building modern, scalable and reliable applications on AWS, one essential service that often goes underappreciated is the AWS Elastic Load Balancer (ELB). Whether you are running web servers, APIs or containerized applications, a load balancer ensures your system stays performant and available even under heavy load.

In this blog, I will break down what an AWS Load Balancer is, how it works, the different types and how to use it effectively to enhance your architecture.

What is an AWS Load Balancer?

An AWS Load Balancer automatically distributes incoming traffic across multiple targets such as EC2 instances, containers, IP addresses and Lambda functions in one or more Availability Zones.

This helps improve fault tolerance, scalability and application performance by preventing any single server from becoming a bottleneck or point of failure.

In simple terms, the AWS Load Balancer acts as the traffic controller for your application directing requests to the best available server.

How Does AWS Load Balancer Work?

Here is what happens when a request hits your AWS Load Balancer:

Client Request → A user or client sends a request to your application
DNS Resolution → The request resolves to your Load Balancer’s DNS name (not directly to a specific instance)
Load Balancer Routing → AWS Load Balancer evaluates which target (EC2 instance, container etc.) is healthiest and least loaded
Forwarding the Request → The Load Balancer forwards the traffic to the selected target
Response to Client → The target processes the request and sends the response back to the client via the Load Balancer

This process ensures seamless performance, high availability and even distribution of traffic.

Types of AWS Load Balancers

AWS offers three main types of load balancers, each serving different use cases:

1. Application Load Balancer (ALB)

Operates at the Application Layer (Layer 7)
Best suited for HTTP and HTTPS traffic
Supports advanced routing features such as:
- Path-based routing (/api, /login)
- Host-based routing (api.example.com, app.example.com)
- Redirects, fixed responses and WebSocket connections.
Ideal for microservices and containerized applications (ECS, EKS).

Use Case: Routing REST APIs or web app traffic between multiple services.

2. Network Load Balancer (NLB)

Operates at the Transport Layer (Layer 4)
Handles TCP, UDP, and TLS traffic
Extremely fast capable of handling millions of requests per second
Provides static IP addresses and ultra low latency

Use Case: Real-time gaming, financial transactions or systems needing extreme performance.

3. Gateway Load Balancer (GLB)

Operates at Layer 3 (Network Layer)
Designed to distribute traffic to third-party virtual appliances like firewalls, intrusion detection systems and deep packet inspection tools
Simplifies the deployment of security and monitoring appliances

Use Case: Deploying network security and monitoring solutions at scale.

Why Use AWS Load Balancer?

Here are some major benefits of using a Load Balancer in your AWS architecture:

Feature	Description
High Availability	Distributes traffic across multiple Availability Zones
Auto Scaling Support	Works seamlessly with Auto Scaling groups
Security Integration	Integrated with AWS Certificate Manager (ACM) for SSL/TLS
Health Checks	Automatically removes unhealthy instances
Seamless Failover	Redirects traffic in case of instance or zone failure
Cost Efficiency	Pay-as-you-go pricing only pay for usage

How to Set Up an AWS Load Balancer

You can easily create a Load Balancer via the AWS Management Console, AWS CLI or Infrastructure as Code (IaC) tools like Terraform or CloudFormation.

Using the AWS Console:

Go to the EC2 Dashboard → Load Balancers
Click Create Load Balancer
Choose the type (Application, Network or Gateway)
Configure:
- Listeners (protocol and port)
- Target Groups (EC2 instances or containers)
- Health Checks
Review and Create the Load Balancer

Once it is live, AWS automatically assigns a DNS name that you can use to access your application.

Pro Tips for Optimizing AWS Load Balancers

Use HTTPS (SSL/TLS) termination at the Load Balancer level for better security
Combine Auto Scaling Groups with ALB for automatic capacity adjustment
Monitor performance using Amazon CloudWatch
Use sticky sessions for applications that require session persistence
Enable cross-zone load balancing to evenly distribute traffic across zones

Real-World Example

Let’s say you run an e-commerce website hosted on three EC2 instances. During a flash sale, thousands of users hit your site simultaneously.

Without a Load Balancer, one instance could crash due to overload.

With an Application Load Balancer, AWS automatically routes traffic to the healthiest instances and scales up or down based on demand ensuring a smooth shopping experience for your customers.

When Should You Use an AWS Load Balancer?

Use AWS Load Balancer when:

Your application runs on multiple EC2 instances
You want to ensure zero downtime during deployments
You are using microservices or containers (ECS/EKS)
You want automatic failover and high availability
You need secure HTTPS routing with SSL certificates

AWS Load Balancer Pricing

AWS Load Balancer pricing is based on:

Load Balancer hours (uptime)
Data processed (GB)
New connections and active flows

You can estimate your cost using the AWS Pricing Calculator

Conclusion

AWS Load Balancer is a powerful and essential component of modern cloud architectures. It enhances performance, availability and scalability ensuring that your users always experience a smooth and reliable service.

Whether you are hosting a small web app or a large-scale enterprise system integrating an AWS Load Balancer is a must for achieving true cloud resilience.

Key Takeaways

Load Balancers distribute traffic evenly across multiple targets
Choose ALB for HTTP/HTTPS, NLB for high-performance TCP/UDP, and GLB for network-level appliances
Combine it with Auto Scaling, CloudWatch, and SSL for optimal performance
AWS ELB is your gateway to highly available, secure, and scalable cloud infrastructure

Author

Khaled Md Saifullah

Full Stack Developer | AWS Enthusiast | Open Source Contributor

GitHub: km-saifullah
LinkedIn: Khaled Md Saifullah

Push Docker Image to AWS ECR

Khaled Md Saifullah — Tue, 07 Oct 2025 17:36:33 +0000

Containerization has changed the way we deploy applications. Instead of worrying about dependencies and configurations, Docker lets us package everything into a portable image. But once you have built your image, where do you store it securely for deployment?

That is where AWS ECR (Elastic Container Registry) comes in.
In this blog, you will learn how to build, containerize and push a simple Nginx website to AWS ECR a fundamental DevOps skill for any intermediate developer.

What is AWS ECR?

Amazon Elastic Container Registry (ECR) is a fully managed container image registry service by AWS.

It allows developers to store, manage and deploy Docker container images securely.

You can think of it as GitHub for Docker images instead of hosting your code, it hosts your container images.

How AWS ECR Works

Build your Docker image locally (using Docker CLI)
Authenticate your Docker client with AWS using your credentials
Push your image to your ECR repository
Deploy it on other AWS services like ECS (Elastic Container Service), EKS (Kubernetes) or EC2

When Should You Use AWS ECR?

You should use AWS ECR when:

You need a private and secure registry for your organization’s Docker images
You are deploying apps to AWS ECS or EKS
You want tight integration with IAM for access control
You need scalable, managed storage for container images

Project Overview

In this project, we will build a simple static website using Nginx and containerize it using Docker.

Then, we will push that Docker image to AWS ECR for deployment.

Technologies Used:

Docker
Nginx
AWS ECR

Project Structure

.
├── Dockerfile
└── index.html

Dockerfile – Defines the Nginx container and copies your static files
index.html – Your website’s main page served by Nginx

Dockerfile

FROM nginx:alpine

COPY index.html /usr/share/nginx/html

EXPOSE 80

Uses a lightweight Nginx image (nginx:alpine)
Copies your static index.html file to the Nginx web directory
Exposes port 80 for incoming web traffic

How to Build and Run Docker Image Locally

Build the Docker Image

docker build -t simple-web-app .

Run the Container

docker run -d -p 8080:80 simple-web-app

Access the Website

Open your browser and visit

http://localhost:8080

You will see your static index.html page being served by Nginx 🎉

Deploying on AWS ECR

Once you have verified it works locally, you can deploy this image to AWS using the following flow:

Push the Image to Amazon ECR (Elastic Container Registry):

aws ecr create-repository --repository-name simple-web-app

aws ecr get-login-password --region <region> | \
docker login --username AWS --password-stdin <aws_account_id>.dkr.ecr.<region>.amazonaws.com

docker tag simple-web-app:latest <aws_account_id>.dkr.ecr.<region>.amazonaws.com/simple-web-app:latest
docker push <aws_account_id>.dkr.ecr.<region>.amazonaws.com/simple-web-app:latest

Pull the Image from ECR (From Any Machine or Server) Once the image is in ECR, you can pull it from anywhere (e.g., EC2 instance, ECS task, or local machine):

Authenticate again:

aws ecr get-login-password --region <region> | \
docker login --username AWS --password-stdin <aws_account_id>.dkr.ecr.<region>.amazonaws.com

Pull the image:

docker pull <aws_account_id>.dkr.ecr.<region>.amazonaws.com/simple-web-app:latest

Run the image:

docker run -d -p 80:80 <aws_account_id>.dkr.ecr.<region>.amazonaws.com/simple-web-app:latest

Now your container is running the image directly from AWS ECR.

Why AWS ECR is a Great Choice?

Fully managed by AWS: no need to host your own registry
Private and secure: integrates with AWS IAM for access control
Scalable and reliable: backed by AWS infrastructure
Cost efficient: pay only for the storage you use
Seamless integration with ECS, EKS and CI/CD pipelines

Conclusion

This project is a simple yet powerful demonstration of how to containerize and deploy web applications using Docker, Nginx and AWS ECR.

You learned how to:

Build and run a Docker container locally
Push it to AWS ECR securely
Pull and deploy it anywhere

Whether you are a developer learning DevOps or planning to deploy production workloads on AWS, mastering ECR and container workflows is an essential step toward modern cloud infrastructure.

Authors

Elastic IP in AWS Explained

Khaled Md Saifullah — Sat, 27 Sep 2025 01:51:31 +0000

When working with cloud infrastructure on Amazon Web Services (AWS), networking is one of the most essential aspects. One common question beginners have is:

👉 “How can I keep the same public IP address for my server, even if I restart or stop it?”

That is where Elastic IP (EIP) comes in. In this guide, I will dive into Elastic IP addresses, covering everything from basic concepts to advanced usage and best practices.

What is an Elastic IP in AWS?

An Elastic IP (EIP) is a static, public IPv4 address provided by AWS. Unlike normal public IPs that can change when you stop/start an EC2 instance. Elastic IPs remain constant and can be remapped to any instance in your AWS account.

Think of it as:

Dynamic Public IP = like our home Wi-Fi, which changes after reboot.
*Elastic IP * = like owning a permanent office address.

Why Use an Elastic IP?

Here are the main benefits:

Consistency → Keeps the same IP even if you restart EC2
Flexibility → Can be remapped between instances during failure
High Availability → Helps in failover scenarios
External Access → Useful when clients or third-party services need a fixed IP

How to Allocate and Associate an Elastic IP (Step-by-Step)

Step 1: Allocate an Elastic IP

Go to AWS Management Console → EC2 Dashboard
In the sidebar, click Elastic IPs
Choose Allocate Elastic IP address
Select Amazon’s pool of IPv4 addresses and confirm

Step 2: Associate Elastic IP with EC2

Select your Elastic IP → Click Actions → Associate Elastic IP address
Choose the EC2 instance or network interface
Click Associate

✅ Done! Now your EC2 instance has a permanent public IP.

Elastic IP with AWS CLI

You can also manage Elastic IPs using the AWS CLI:

Allocate Elastic IP:

aws ec2 allocate-address --domain vpc

Associate Elastic IP:

aws ec2 associate-address \
    --instance-id i-1234567890abcdef0 \
    --allocation-id eipalloc-12345678

Release Elastic IP:

aws ec2 release-address --allocation-id eipalloc-12345678

Use Cases of Elastic IP

Production Servers → Keep the same IP for web apps or APIs
Disaster Recovery → Quickly remap IP to a standby instance
Whitelisted Services → If your app connects to third-party APIs that require fixed IPs
DNS Mapping → Point your domain/subdomain to a permanent IP

Pricing and Best Practices

Elastic IP is free as long as it is attached to a running EC2 instance
AWS charges for unused Elastic IPs

Best practice

Do not reserve unused EIPs
Use Elastic Load Balancers (ELB) or Route 53 for scalability instead of relying solely on EIPs

Conclusion

An Elastic IP in AWS is a powerful way to maintain stable and reliable connectivity for your applications. While they are extremely useful, always follow best practices and avoid keeping unused Elastic IPs to save costs.

By mastering Elastic IP, you take a solid step forward in understanding AWS networking from beginner to advanced.

A complete IPv4 CIDR Addressing Guide for DevOps Engineers From subnetting basics to cloud networking use cases this blog has everything you need.

Khaled Md Saifullah — Wed, 10 Sep 2025 17:25:06 +0000

Khaled Md Saifullah

Sep 10 '25

Understanding IPv4 CIDR Addressing: A Complete Guide for DevOps Engineers

#ipv4 #devops #networking

Comments

3 min read

Understanding IPv4 CIDR Addressing: A Complete Guide for DevOps Engineers

Khaled Md Saifullah — Wed, 10 Sep 2025 17:17:22 +0000

If you are a DevOps engineer, network engineer or someone working with cloud infrastructure, understanding IPv4 CIDR addressing is a must. CIDR (Classless Inter-Domain Routing) is used everywhere cloud networking (AWS, Azure, GCP), Docker, Kubernetes and VPNs.

This blog takes you from beginner to advanced concepts of CIDR addressing in IPv4, so you can design and troubleshoot networks with confidence.

What is IPv4?
What is CIDR?
Why CIDR Replaced Classes?
CIDR Notation Explained
Subnetting with CIDR
CIDR Examples
CIDR in DevOps Use Cases
CIDR Cheatsheet
Advanced Concepts
Final Thoughts

What is IPv4?

IPv4 (Internet Protocol version 4) is the fourth version of IP used to identify devices on a network
It uses 32-bit addresses, written as four octets (e.g. 192.168.1.1)
The total number of IPv4 addresses = 2³² = 4,294,967,296

What is CIDR?

CIDR (Classless Inter-Domain Routing) is a method for allocating IP addresses and routing efficiently.

Instead of using fixed class based networks (A, B, C), CIDR allows flexible subnetting.

👉 Example:

Old class-based: 192.168.1.0 (Class C = 255.255.255.0)
With CIDR: 192.168.1.0/24

Here, /24 means 24 bits for the network and 8 bits for hosts.

Why CIDR Replaced Classes?

Earlier, IP addresses were divided into classes:

Class A → /8 (16M hosts)
Class B → /16 (65K hosts)
Class C → /24 (256 hosts)

Problem: Too much wastage of IPs

👉 CIDR solved this by allowing variable-length subnet masks (VLSM).

CIDR Notation Explained

CIDR notation = IP address + /prefix length

Example: 10.0.0.0/16
/16 means first 16 bits = network part
Remaining bits = host part

Formula:

Number of hosts = 2^(32 - prefix) - 2 (subtract 2 for network and broadcast addresses)

Subnetting with CIDR

Subnetting allows dividing a network into smaller parts

Example:

Network: 192.168.0.0/24 (256 addresses)
Subnet: 192.168.0.0/26 (64 addresses each)

Subnets:

192.168.0.0/26 → 64 IPs
192.168.0.64/26 → 64 IPs
192.168.0.128/26 → 64 IPs
192.168.0.192/26 → 64 IPs

CIDR Examples

CIDR Block	Subnet Mask	Hosts Available	Example Usage
/8	255.0.0.0	16M hosts	Large ISPs
/16	255.255.0.0	65K hosts	Campus network
/24	255.255.255.0	254 hosts	Home/Office LAN
/30	255.255.255.252	2 hosts	Point-to-point links
/32	255.255.255.255	1 host	Single device (loopback, VPN)

CIDR in DevOps Use Cases

CIDR is widely used in cloud and DevOps:

AWS VPC → Create VPC with 10.0.0.0/16 and subnets /24
Kubernetes → Pod networks (10.244.0.0/16)
Docker → Default bridge network uses 172.17.0.0/16
VPNs → Assign ranges like 192.168.100.0/24

💡 Always plan CIDR ranges carefully to avoid overlapping networks

CIDR Cheatsheet

CIDR	Hosts Available	Netmask
/8	16,777,214	255.0.0.0
/16	65,534	255.255.0.0
/24	254	255.255.255.0
/30	2	255.255.255.252
/32	1	255.255.255.255

Advanced Concepts

Supernetting → Aggregating multiple subnets into one larger block (useful for ISPs)
Route Summarization → Reducing routing table entries with CIDR
Overlapping CIDRs → Avoid in hybrid cloud/VPN setups
IPv6 CIDR → Works similarly but with 128-bit addresses

Final Thoughts

CIDR is the foundation of modern networking
DevOps engineers must master CIDR to manage cloud, Kubernetes, and Docker networks
From /8 to /32, CIDR lets you optimize IP allocation and reduce network waste

👉 Next time you create a VPC, configure Kubernetes or debug a VPN CIDR will be at the heart of it.

If you found this blog helpful, do not forget to 💖 star this repo, share and follow for more DevOps and networking content.

Mastering Linux Processes: From Beginner to Advanced Guide

Khaled Md Saifullah — Tue, 09 Sep 2025 18:29:20 +0000

If you have ever worked with Linux, you have probably heard the term “process”. But what exactly is a Linux process, how does it work and why is it so important for system administration, performance and security?

In this blog, I will dive into Linux processes step by step starting from the basics and moving towards advanced concepts. Whether you are a beginner exploring Linux for the first time or an experienced sysadmin, this post will level up your understanding.

What is a Process in Linux?

A process in Linux is simply a program in execution.

Whenever you run a command or application, Linux creates a process for it.

Example:

$ firefox

When you run this command, Linux creates a new process for Firefox.

Each process is assigned a Process ID (PID) which makes it uniquely identifiable.

Key Components of a Process

PID (Process ID) → Unique number to identify each process.
PPID (Parent Process ID) → The process that started (parent) the current process.
UID (User ID) → The owner of the process.
Priority & Scheduling → Determines how CPU time is shared.
State → Running, Sleeping, Stopped, or Zombie.

👉 You can check running processes with

ps aux

Types of Linux Processes

Foreground Process → Runs interactively (nano, top)
Background Process → Runs silently in the background
Daemon Process → System services like sshd, cron
Zombie Process → Dead process not cleared by its parent
Orphan Process → Parent terminated, but child is still running

Essential Commands to Manage Processes

Here are the most commonly used process management commands in Linux:

Command	Description
`ps`	Displays active processes
`top`	Real-time process monitoring
`htop`	Advanced version of `top` (interactive)
`kill <PID>`	Terminates a process by PID
`killall <name>`	Kills processes by name
`nice`	Starts a process with a priority
`renice`	Changes priority of running processes
`jobs`	Lists background jobs
`fg %1`	Brings job to foreground
`bg %1`	Resumes job in background

Monitoring Processes Like a Pro

Linux provides tools to monitor and optimize processes:

top → CPU & memory usage in real time
htop → Colorful, user friendly monitoring
atop → Detailed performance analysis
systemctl → Manage daemon processes

Example

htop

This will show you interactive process stats with CPU, memory, and more.

Advanced Topics in Linux Processes

1️⃣ Process States

Running (R) → Currently active
Sleeping (S) → Waiting for resources
Stopped (T) → Halted process
Zombie (Z) → Process finished but still in process table

2️⃣ Signals

Linux uses signals to control processes.

Common signals:

SIGTERM (15) → Graceful stop
SIGKILL (9) → Force kill (can’t be ignored)
SIGSTOP (19) → Pause process
SIGCONT (18) → Resume process

kill -9 1234

Note: This kills the process with PID 1234.

3️⃣ Process Priorities (Nice & Renice)

Every process has a priority (niceness value) from - 20 (highest) to 19 (lowest).

nice -n 10 myscript.sh
renice -n -5 -p 2345

4️⃣ Process Scheduling

Linux uses schedulers (CFS, Deadline, RT) to decide which process gets CPU time.

Practical Example: Running a Background Process

# Run a script in the background
./backup.sh &

# Check jobs
jobs

# Bring process to foreground
fg %1

This is commonly used for long running scripts like backups, servers and cron jobs.

Security & Process Management

Always check suspicious processes using:

ps aux | grep suspicious

Use top/htop to detect high CPU/memory usage.
Restrict permissions so untrusted users can not run malicious processes.
Automate process monitoring with cron jobs or tools like Monit.

Conclusion

Linux processes are the backbone of system performance.
From understanding basic commands to mastering advanced scheduling and signals, process management is a skill every developer, sysadmin and DevOps engineer must have.

By learning how to monitor, control and optimize processes, you can ensure your Linux system runs efficiently, securely and reliably.

If you found this helpful, follow me for more Linux, DevOps and MERN stack tutorials. 🚀

How a Web Server Works - From Beginner to Advanced

Khaled Md Saifullah — Sun, 07 Sep 2025 16:47:46 +0000

Have you ever wondered what really happens when you type a URL like www.google.com into your browser and hit Enter?

Behind the scenes, a web server plays the central role in delivering that website to your screen.

In this blog, I will cover how a web server works starting from the beginner friendly basics and moving towards concepts that even advanced developers should know.

Whether you are just starting with web development or are a seasoned backend engineer, this blog will help you understand the core engine of the web.

What is a Web Server?

A web server is a software (sometimes hardware) that:

Stores, processes and delivers web content (HTML, CSS, JS, images, APIs)
Uses the HTTP/HTTPS protocol to communicate with browsers (clients)
Runs continuously to serve multiple requests from users worldwide

Popular Web Servers:

Apache (Open-source, widely used)
Nginx (Lightweight, fast, handles concurrent requests)
Microsoft IIS
LiteSpeed

How a Web Server Works - Step by Step

1. User Request (Client Side)

You type https://example.com in your browser
The browser sends an HTTP request to the server hosting that domain

2. DNS Resolution

The domain (example.com) is mapped to an IP address via the Domain Name System (DNS)
Example: example.com → 192.168.1.1

3. TCP/IP Connection

The browser establishes a connection using TCP/IP with the server’s IP
If it is HTTPS, an SSL/TLS handshake happens for encryption

4. Server Processing

The web server receives the request
It checks if it’s a static file (HTML, CSS, image) or requires dynamic content (PHP, Node.js, Python etc.)
For dynamic content, the server passes the request to an application server (e.g. Express.js, Django, Laravel)

5. Database Query (if needed)

If the request involves user data, product lists, or authentication, the server fetches data from a database (MySQL, MongoDB, PostgreSQL)

6. Response Sent Back

The server sends back an HTTP response with:
- Status Code (200 OK, 404 Not Found, 500 Server Error)
- The requested data (HTML page, JSON response etc.)

7. Browser Renders Content

The browser receives the response
Parses the HTML, loads CSS/JS, and finally renders the webpage for the user

Beginner to Advanced Concepts

Beginner Concepts

HTTP vs HTTPS → Secure data transfer
Static vs Dynamic Websites → Prebuilt files vs generated on the fly
Client-Server Model → Browser (client) vs Server (backend)

Intermediate Concepts

Load Balancing → Distributing requests across multiple servers.
Caching → Storing data temporarily for faster responses (CDN, browser cache)
Session Management → Handling user login, cookies, tokens

Advanced Concepts

Reverse Proxy → Nginx/HAProxy handling traffic before backend servers
API Gateways → Managing microservices and requests
Scalability → Horizontal scaling (adding more servers) & vertical scaling (upgrading server resources)
Security → DDoS protection, WAF (Web Application Firewall), SSL/TLS encryption

Example Workflow Diagram

[ Browser ] --> [ DNS Lookup ] --> [ Web Server ] --> [ App Server ] --> [ Database ]
      ^                                                           |
      |---------------------- Response Back ----------------------|

Why Developers Should Understand Web Servers

Helps debug performance bottlenecks
Essential for deploying apps on platforms like AWS, Vercel or DigitalOcean
Enables writing scalable, secure applications
Builds knowledge of networking, security and system design

Key Takeaways

A web server is the backbone of the internet, delivering content to users
From typing a URL to seeing a webpage, multiple layers like DNS, TCP/IP, SSL, and HTTP are involved
Beginners should focus on client-server basics, while advanced developers should explore load balancing, caching, and security

Conclusion

Understanding how a web server works is non-negotiable for every developer. Whether you are building a personal portfolio site or a large scale SaaS platform, knowing the internals of servers will help you build faster, safer= and more scalable web applications.

Thanks for reading!

If you found this helpful, don’t forget to 💖 like and 📝 comment on this post.

👉 Follow me for more blogs on Web Development, MERN Stack and System Design!

VIM Editor Tutorial for Beginners – Learn VIM the Easy Way

Khaled Md Saifullah — Fri, 05 Sep 2025 06:20:14 +0000

VIM is one of the most powerful text editors available in Linux and Unix systems. It can be intimidating for beginners, but once you get the basics, you will realize how fast and efficient it is. This tutorial will walk you through VIM for beginners with simple examples so you can start using it confidently.

What is VIM?

VIM (Vi Improved) is an advanced version of the classic Vi editor. It is:

Pre installed on most Linux systems
Lightweight and super fast
Great for developers, sysadmins and power users

VIM is keyboard driven, meaning you can do everything without a mouse. This makes editing faster once you learn the commands.

How to Open and Exit VIM

To open a file in VIM:

vim filename.txt

If the file does not exist, VIM will create it.

To exit VIM:

Press Esc (to make sure you’re not in insert mode)
Type one of the following:
- :q → Quit
- :q! → Quit without saving
- :wq → Save and quit
- :w → Save without quitting

VIM Modes Explained

VIM works in different modes:

Normal Mode – Default mode (for navigation and commands)
Insert Mode – For typing text (press i to enter)
Command Mode – For running commands (press :)

👉 Quick switch:

i → Insert mode
Esc → Back to Normal mode
: → Command mode

Basic Navigation in VIM

In Normal Mode:

h → Move left
l → Move right
k → Move up
j → Move down

👉 Tip: You can also use arrow keys, but learning hjkl will make you faster.

Editing Text in VIM

Insert Text

i → Insert before cursor
a → Append after cursor
o → Open a new line below

Delete Text

x → Delete one character
dd → Delete a whole line
dw → Delete a word

Copy & Paste

yy → Copy a line (yank)
p → Paste after cursor

Undo & Redo

u → Undo
Ctrl + r → Redo

Searching and Replacing

Search

To search for a word:

/word

Press n for next match, N for previous.

Replace

To replace "old" with "new":

:%s/old/new/g

Example Workflow in VIM

Open a file:

   vim hello.txt

Press i and type:

   Hello VIM!
   This is my first file.

Press Esc
Save and exit:

:wq

Pro Tips for Beginners

Use vimtutor command in terminal for practice
Start with basic commands before advanced features
Don’t worry about speed at first accuracy matters

Conclusion

VIM may look difficult at the beginning, but with practice, you will become faster and more efficient than using any graphical editor. Start with small steps, practice the basics and soon you will love working with VIM.

👉 Try opening a file right now and test these commands. The more you practice, the easier VIM becomes.

Did this tutorial help you? Share your thoughts in the comments on dev.to.

Forem: Khaled Md Saifullah

The Ultimate Guide to MongoDB Aggregation Pipeline | Concepts, Use Cases and Real Code Examples

What Is Aggregation Pipeline in MongoDB?

Why Is Aggregation Pipeline Necessary?

Where Do We Use MongoDB Aggregation Pipelines?

Mini Project: Aggregation Pipeline with Node.js

Test the API

Conclusion

Horizontal Scaling Strategies for Node.js Applications

Why Horizontal Scaling?

Node.js Clustering (Multi-Core Utilization)

Load Balancing Node.js Apps

Container Based Horizontal Scaling (Docker with Kubernetes)

Distributed Caching with Redis

Message Queues for Async Processing (RabbitMQ / BullMQ)

Stateless Application Architecture

Microservices & Event-Driven Architecture

Real-Time Applications Scaling

Database Sharding & Replication

Conclusion

Redis Explained: What It Is, Why Developers Use It and the Problems It Solves

Introduction

What Is Redis?

Key Features

Why Do We Use Redis?

What Problems Does Redis Solve?

Real life Example: Using Redis as a Cache

Where Is Redis Commonly Used?

Summary

Final Thoughts

Backend Security for Express.js (With Nginx + VPS)

Table of Contents

Threat Model

Why Backend Security is Critical

Security Baseline

Minimum production requirements

Project Setup

Install required dependencies

Application Layer Security

Reverse Proxy Layer (Nginx)

VPS Hardening (Server Level)

Deployment checklist

Final Security Rule

Conclusion

Understanding AWS Load Balancer: The Ultimate Guide to Scalable and Reliable Applications

What is an AWS Load Balancer?

How Does AWS Load Balancer Work?

Types of AWS Load Balancers

1. Application Load Balancer (ALB)

2. Network Load Balancer (NLB)

3. Gateway Load Balancer (GLB)

Why Use AWS Load Balancer?

How to Set Up an AWS Load Balancer

Using the AWS Console:

Pro Tips for Optimizing AWS Load Balancers

Real-World Example

When Should You Use an AWS Load Balancer?

AWS Load Balancer Pricing

Conclusion

Key Takeaways

Author

Tags

Push Docker Image to AWS ECR

What is AWS ECR?

How AWS ECR Works

When Should You Use AWS ECR?

Project Overview

Project Structure

Dockerfile

How to Build and Run Docker Image Locally

Run the Container

Access the Website

Deploying on AWS ECR

Why AWS ECR is a Great Choice?

Conclusion

Authors

Elastic IP in AWS Explained

What is an Elastic IP in AWS?

Why Use an Elastic IP?

How to Allocate and Associate an Elastic IP (Step-by-Step)