DEV Community: Mohin Sheikh

Building an AI-Powered Financial Wellness Assistant with Node.js and TypeScript

Mohin Sheikh — Tue, 23 Jun 2026 16:01:26 +0000

Introduction

What if employees could instantly understand their payslip, deductions, and tax-saving opportunities without bothering HR or Payroll teams?

In this post, I'll walk you through building a secure AI-powered financial wellness assistant that does exactly that. This system analyzes both structured payroll data and uploaded payslip documents, then provides document-grounded explanations in simple, employee-friendly language.

The Problem We're Solving

Employees frequently find payslips difficult to interpret because salary components, statutory deductions, reimbursements, and year-to-date values are often presented in a compact and technical format. This creates repeated queries for Payroll, HR, and Finance teams.

Common employee questions:

"Why is my net salary lower this month?"
"How much HRA did I receive?"
"What deductions were applied?"
"How can I save more tax?"

The objective is to reduce operational load by providing instant, personalized, and document-aware responses while maintaining strict user-level privacy for sensitive financial information.

What We Built

A complete AI-powered financial wellness assistant with:

Secure Authentication - JWT-based authentication with role-based access control
Payslip Processing - Upload PDF or images, extract data using AI vision capabilities
AI-Powered Q&A - Ask natural language questions with grounded responses
Tax Simulation - See impact of additional investments on tax liability
Investment Checklist - Personalized proof submission checklist
YTD Summary - Year-to-date salary and tax summary
Trend Analysis - Salary comparison across months
Salary Breakdown - Detailed view of earnings and deductions

Technology Stack

Layer	Technology
Backend	Node.js, Express.js, TypeScript
AI Integration	LLM Wrapper API (Gemini/Claude models)
Frontend	HTML, CSS, JavaScript (Vanilla)
Security	JWT, Role-Based Access Control
Testing	Jest
API Documentation	Postman

System Architecture

┌─────────────────────────────────────────────────────┐
│              Frontend (HTML/CSS/JS)                 │
│              http://localhost:3000                  │
└────────────────────┬────────────────────────────────┘
                     │
┌────────────────────▼────────────────────────────────┐
│              Express.js API Server                  │
│  ┌──────────────────────────────────────────────┐  │
│  │  Routes Layer (auth/payslip/tax/query)      │  │
│  └──────────────┬───────────────────────────────┘  │
│  ┌──────────────▼───────────────────────────────┐  │
│  │  Middleware (Auth/RBAC/RateLimit)           │  │
│  └──────────────┬───────────────────────────────┘  │
│  ┌──────────────▼───────────────────────────────┐  │
│  │  Core Services (Payroll/Tax/Document)       │  │
│  └──────────────┬───────────────────────────────┘  │
│  ┌──────────────▼───────────────────────────────┐  │
│  │  External Services (LLM Wrapper API)        │  │
│  └──────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘

Project Structure

financial-wellness-ai-agent/
├── src/
│   ├── config/               # Configuration files
│   │   └── llm.config.ts
│   ├── core/                 # Core business logic
│   │   ├── payroll.service.ts
│   │   ├── tax.service.ts
│   │   └── document.service.ts
│   ├── models/               # Data models
│   │   └── index.ts
│   ├── security/             # Authentication and authorization
│   │   └── auth.middleware.ts
│   ├── services/             # External service integrations
│   │   └── llm.service.ts
│   ├── routes/               # API routes
│   │   ├── auth.routes.ts
│   │   ├── payslip.routes.ts
│   │   ├── tax.routes.ts
│   │   └── query.routes.ts
│   ├── prompts/              # AI prompt engineering
│   │   └── grounding.prompts.ts
│   ├── utils/                # Helpers and utilities
│   │   ├── logger.ts
│   │   └── error-handler.ts
│   ├── data/                 # Mock data
│   │   └── mock-data.ts
│   ├── app.ts                # Express app setup
│   └── server.ts             # Server entry point
├── public/                   # Static frontend files
│   └── index.html
├── tests/                    # Unit and integration tests
│   ├── unit/
│   └── integration/
├── contrib/                  # Contribution files
│   ├── postman_collection.json
│   └── postman_environment.json
├── .env.example              # Environment variables template
├── package.json
├── tsconfig.json
└── README.md

Key Features Explained

1. Secure Authentication

JWT-based authentication with role-based access control ensures that employees can only access their own data.

export const authenticate = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) return res.status(401).json({ error: 'Unauthorized' });

  const decoded = verifyToken(token);
  req.user = { id: decoded.userId, role: decoded.role };
  next();
};

2. AI-Powered Document Processing

The system uses AI vision to extract structured data from payslip documents:

export const EXTRACT_PAYSLIP_PROMPT = `
You are a payroll data extraction assistant. Analyze the provided payslip document 
and extract the following fields in a valid JSON format.

Fields to extract:
- basicSalary (number)
- hra (number)
- pf (number)
- tds (number)
- grossPay (number)
- netPay (number)
- month (string)
`;

3. Grounded AI Responses

All AI responses are grounded in the user's actual payroll data to prevent hallucinations:

export const GROUNDED_QUERY_PROMPT = (userQuery, userData) => `
You are an employee-friendly financial wellness assistant.

STRICT GROUNDING RULES:
1. ONLY use information present in the provided data
2. If information is missing, say: "I don't have enough information"
3. DO NOT invent figures, tax rules, or financial advice
4. Use simple, clear language

USER'S DATA: ${JSON.stringify(userData)}

USER'S QUESTION: ${userQuery}
`;

4. Tax Simulation

Simplified tax calculation with simulation capabilities:

export class TaxService {
  private static readonly TAX_SLABS = [
    { limit: 250000, rate: 0 },
    { limit: 500000, rate: 0.05 },
    { limit: 1000000, rate: 0.20 },
    { limit: Infinity, rate: 0.30 },
  ];

  static simulateInvestment(records, additionalInvestment) {
    const annualIncome = this.calculateAnnualIncome(records);
    const currentTax = this.calculateTax(annualIncome, currentDeductions);
    const proposedTax = this.calculateTax(annualIncome, currentDeductions + additionalInvestment);

    return {
      taxSavings: currentTax.totalTax - proposedTax.totalTax,
      roi: (savings / additionalInvestment) * 100
    };
  }
}

API Endpoints Overview

Authentication

Method	Endpoint	Description
POST	`/api/auth/login`	Login user

Payslip Management

Method	Endpoint	Description
POST	`/api/payslip/upload`	Upload payslip
GET	`/api/payslip/records`	Get all records
GET	`/api/payslip/ytd`	YTD summary
POST	`/api/payslip/compare`	Compare months

AI Queries

Method	Endpoint	Description
POST	`/api/query/ask`	Ask AI question
POST	`/api/query/explain`	Explain component

Tax Services

Method	Endpoint	Description
GET	`/api/tax/summary`	Tax summary
POST	`/api/tax/simulate`	Tax simulation
GET	`/api/tax/checklist`	Investment checklist

Demo Walkthrough

1. Login

POST /api/auth/login
{
  "email": "john.doe@company.com",
  "password": "demo123"
}

2. Ask AI Question

POST /api/query/ask
{
  "question": "How much HRA did I receive?"
}

Response:

Your HRA (House Rent Allowance) breakdown:

Latest Month (June 2026):
- HRA Received: ₹19,553
- HRA Exemption (tax-free): ₹9,777

Month-by-Month Summary:
- June 2026: ₹19,553
- May 2026: ₹19,740
- April 2026: ₹20,649
- Total YTD: ₹1,21,493

3. Tax Simulation

POST /api/tax/simulate
{
  "additionalInvestment": 50000
}

Response:

Tax Savings Simulation:

Additional Investment: ₹50,000
Current Tax: ₹1,820
Proposed Tax: ₹1,450
Tax Savings: ₹370 (annual)
ROI: 0.74%

Installation and Setup

# Clone the repository
git clone git@github.com:mohin-sheikh/ai-financial-assistant.git
cd ai-financial-assistant

# Install dependencies
npm install

# Create environment file
cp .env.example .env

# Add your LLM API token to .env
LLM_API_TOKEN=your_token_here

# Build the project
npm run build

# Start the server
npm start

# Or development mode with auto-reload
npm run dev

Demo Credentials

Role	Email	Password
Employee	john.doe@company.com	demo123
Admin	admin@company.com	admin123

Testing

# Run all tests
npm test

# Run tests with watch mode
npm run test:watch

# Run specific test file
npm test -- tests/unit/tax.service.test.ts

Security Features

JWT-based authentication with expiry
Role-based access control (Employee, Admin, Payroll)
User-level data isolation
Rate limiting (100 requests per 15 minutes)
Audit logging for all user actions
Input validation and sanitization
Helmet.js for security headers

Postman Collection

A complete Postman collection is available in the contrib/ directory:

postman_collection.json - All API endpoints with examples
postman_environment.json - Environment variables for testing

To import:

Open Postman
Click "Import"
Select the JSON files from contrib/
Select the environment
Run "Login - Employee" first to get the token

Key Learnings and Takeaways

1. AI Grounding is Critical

Always ground AI responses in actual user data. This prevents hallucinations and builds trust.

2. Security First

Financial data requires strict user-level isolation, JWT authentication, and audit logging.

3. Simple Tax Logic

For prototypes, simplified tax logic is acceptable as long as assumptions are clearly documented.

4. User-Friendly Language

Translate technical payroll jargon into simple, employee-friendly explanations.

5. Document Grounding

Use AI vision capabilities to extract structured data from unstructured documents.

Challenges and Solutions

Challenge 1: Preventing AI Hallucinations

Solution: Strict grounding prompts that force the AI to only use provided data.

Challenge 2: Document Extraction Accuracy

Solution: Combined regex fallback with AI vision for better extraction.

Challenge 3: User Data Isolation

Solution: JWT-based authentication with middleware that checks data ownership.

Challenge 4: Time Constraint (1 Hour)

Solution: Prioritized core features over production polish, used mock data instead of real database.

Future Enhancements

[ ] Persistent database (PostgreSQL/MongoDB)
[ ] Real OCR integration (Tesseract/Google Vision)
[ ] Multi-month comparison charts
[ ] PDF payslip generation
[ ] Email notifications for tax deadlines
[ ] Mobile responsive UI
[ ] Export to Excel/CSV
[ ] Advanced tax rules (new/old regime)
[ ] Multi-company support
[ ] Dashboard with visual analytics

GitHub Repository

Star, Fork, and Contribute: https://github.com/mohin-sheikh/ai-financial-assistant

git clone git@github.com:mohin-sheikh/ai-financial-assistant.git
cd ai-financial-assistant
npm install
npm run dev

Conclusion

Building an AI-powered financial wellness assistant demonstrates how AI can be safely and practically applied in an internal employee-finance use case where trust, correctness, and privacy are critical.

The system provides instant, personalized, and document-aware responses while maintaining strict user-level privacy for sensitive financial information. This prototype showcases:

AI-powered document understanding
Grounded responses with no hallucinations
User-friendly explanations
Secure data handling
Scalable architecture

Share Your Thoughts

I'd love to hear your feedback! Have you built something similar? What features would you add?

GitHub: mohin-sheikh
LinkedIn: mohin-sheikh

I Spent 30 Days Building a Complete Node.js Learning Path (Free for Everyone)

Mohin Sheikh — Sat, 13 Jun 2026 15:40:11 +0000

What This Repository Is

A complete, structured, beginner-friendly Node.js learning path.

30 sessions.

Each session has

Clear learning objectives
Step-by-step explanations
Working code examples
Practice exercises
Interview questions
Summary of key points

No fluff. No assumptions. Just code.

The Complete Curriculum

Phase 1 - Node.js Fundamentals (Sessions 1-5)

Session	Topic	What You Will Build
01	Introduction to Node.js	Your first Node.js program
02	Project Setup and npm	package.json, node_modules
03	How Node.js Works	Event loop, blocking vs non-blocking
04	Modules and Imports	Your first custom module
05	File System Module	Read, write, update, delete files

Sample code from Session 05

const fs = require("fs");

// Create a file
fs.writeFileSync("student.txt", "Welcome To Node.js");

// Read the file
const data = fs.readFileSync("student.txt", "utf8");
console.log(data); // Welcome To Node.js

// Append to file
fs.appendFileSync("student.txt", "\nNew line added");

// Delete file
fs.unlinkSync("student.txt");

Phase 2 - Core Modules (Sessions 6-10)

Session	Topic	What You Will Build
06	Path Module	Cross-platform file paths
07	OS Module	System information
08	Events and EventEmitter	Custom event handling
09	HTTP Module	Create a server
10	Multi-Route Server	Multiple routes, JSON responses

Sample code from Session 10

const http = require("http");

const server = http.createServer((req, res) => {
  if (req.url === "/") {
    res.end("Home Page");
  } else if (req.url === "/about") {
    res.end("About Page");
  } else if (req.url === "/products") {
    res.setHeader("Content-Type", "application/json");
    res.end(JSON.stringify([{ id: 1, name: "Laptop" }]));
  } else {
    res.statusCode = 404;
    res.end("Page Not Found");
  }
});

server.listen(3000);

Phase 3 - Building REST APIs (Sessions 11-15)

Session	Topic	What You Will Build
11	CRUD with Dummy Data	Complete REST API using array
12	Introduction to Express	First Express server
13	Express Routing	Route params, query params
14	Middleware	Custom middleware, logging, auth
15	REST APIs with Express	Professional API structure

Sample code from Session 15

const express = require("express");
const app = express();

let students = [
  { id: 1, name: "John", age: 20 },
  { id: 2, name: "Jane", age: 22 }
];

// GET all students
app.get("/students", (req, res) => {
  res.json({ success: true, data: students });
});

// GET single student
app.get("/students/:id", (req, res) => {
  const student = students.find(s => s.id === parseInt(req.params.id));
  if (!student) {
    return res.status(404).json({ success: false, message: "Not found" });
  }
  res.json({ success: true, data: student });
});

// POST create student
app.post("/students", (req, res) => {
  const newStudent = { id: students.length + 1, ...req.body };
  students.push(newStudent);
  res.status(201).json({ success: true, data: newStudent });
});

app.listen(3000);

Phase 4 - Databases (Sessions 16-20)

Session	Topic	What You Will Build
16	Environment Variables	.env, dotenv, configuration
17	MongoDB Introduction	MongoDB Atlas setup
18	MongoDB CRUD	Native MongoDB driver
19	Mongoose	Schemas, models, validation
20	Express + MongoDB API	Complete database-backed API

Sample code from Session 20

const mongoose = require("mongoose");

const studentSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  age: { type: Number, min: 18, max: 60 },
  course: { type: String }
}, { timestamps: true });

const Student = mongoose.model("Student", studentSchema);

// API endpoint
app.post("/students", async (req, res) => {
  try {
    const student = await Student.create(req.body);
    res.status(201).json({ success: true, data: student });
  } catch (error) {
    res.status(400).json({ success: false, message: error.message });
  }
});

Phase 5 - Professional Features (Sessions 21-25)

Session	Topic	What You Will Build
21	MVC Architecture	Models, Views, Controllers separation
22	JWT Authentication	Register, login, protected routes
23	bcrypt Password Hashing	Secure password storage
24	Error Handling	Centralized error handling
25	File Uploads	Multer, profile pictures

Sample code from Session 22

const jwt = require("jsonwebtoken");
const bcrypt = require("bcryptjs");

// Register
app.post("/register", async (req, res) => {
  const { name, email, password } = req.body;

  const hashedPassword = await bcrypt.hash(password, 10);

  const user = await User.create({
    name,
    email,
    password: hashedPassword
  });

  const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET);

  res.json({ success: true, token });
});

// Protected route middleware
const protect = async (req, res, next) => {
  const token = req.headers.authorization?.split(" ")[1];

  if (!token) {
    return res.status(401).json({ message: "Not authorized" });
  }

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = await User.findById(decoded.id);
    next();
  } catch (error) {
    res.status(401).json({ message: "Invalid token" });
  }
};

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

Phase 6 - Production Readiness (Sessions 26-30)

Session	Topic	What You Will Build
26	Logging	Morgan, Winston, log files
27	API Documentation	Swagger, OpenAPI
28	Testing	Jest, Supertest
29	Project Structure	Professional folder organization
30	Mini Project	Complete Task Management API

The Final Project - Task Management API

Session 30 is a complete, production-ready API

Features

User registration and login (JWT)
Create, read, update, delete tasks
Filter tasks by status (pending/completed)
Pagination for task list
Profile picture upload (Multer)
Password reset via email
Task statistics dashboard
Complete error handling
Unit and integration tests
Environment configuration
Professional folder structure

Project Structure

task-management-api/
│
├── src/
│   ├── config/           # Database configuration
│   ├── constants/        # Status codes, error messages
│   ├── controllers/      # Business logic
│   ├── middleware/       # Auth, validation, error handling
│   ├── models/          # User, Task schemas
│   ├── routes/          # API endpoints
│   ├── services/        # Email service
│   ├── utils/           # Helpers, response formatter
│   └── app.js           # Express configuration
│
├── tests/               # Unit and integration tests
├── uploads/             # Profile pictures
├── logs/                # Application logs
├── .env                 # Environment variables
├── server.js            # Entry point
└── package.json

API Endpoints You Will Build

Authentication
POST   /api/auth/register        - Create account
POST   /api/auth/login           - Login
GET    /api/auth/me              - Get profile
PUT    /api/auth/profile         - Update profile
POST   /api/auth/forgot-password - Reset password

Tasks
GET    /api/tasks                - List tasks (with filters)
POST   /api/tasks                - Create task
GET    /api/tasks/stats          - Task statistics
GET    /api/tasks/:id            - Get single task
PUT    /api/tasks/:id            - Update task
PATCH  /api/tasks/:id/status     - Update status
DELETE /api/tasks/:id            - Delete task

Users
POST   /api/users/upload-profile - Upload picture
DELETE /api/users/account        - Delete account

Repository Statistics

30 session folders
30 detailed README files
100+ code examples
50+ practice exercises
100+ interview questions
1 complete mini project

Sample Practice Exercises

From Session 11 (CRUD Operations)

Exercise 1 - Create a Products API with name, price, category
Exercise 2 - Add validation to POST request
Exercise 3 - Add search feature GET /students?search=John
Exercise 4 - Prevent duplicate emails

From Session 22 (Authentication)

Exercise 1 - Add password reset feature
Exercise 2 - Add logout with token blacklist
Exercise 3 - Add refresh token functionality
Exercise 4 - Add rate limiting to login route

From Session 30 (Mini Project)

Exercise 1 - Add categories to tasks
Exercise 2 - Send email reminders before due date
Exercise 3 - Allow task sharing between users
Exercise 4 - Add comments on tasks
Exercise 5 - Deploy to production

Sample Interview Questions Covered

Each session includes 5-10 interview questions with answers

From Session 03 (How Node.js Works)

Is Node.js single threaded?
What is the event loop?
What is blocking vs non-blocking code?

From Session 22 (JWT Authentication)

What is JWT and how does it work?
What are the three parts of a JWT?
Difference between authentication and authorization?

From Session 24 (Error Handling)

What is the difference between operational and programming errors?
How do you handle async errors in Express?
What is unhandledRejection?

What Students Will Be Able to Do After Completing

Build REST APIs from scratch
Implement JWT authentication
Work with MongoDB and Mongoose
Handle file uploads
Write tests for APIs
Document APIs with Swagger
Structure professional projects
Debug and fix errors
Deploy applications
Answer Node.js interview questions

Time Commitment

Background	Time Needed
Complete beginner (learning JavaScript along the way)	6-8 weeks
Knows JavaScript basics	4-6 weeks
Some backend experience	2-3 weeks
One session per day	30 days

Requirements Before Starting

Basic JavaScript (variables, functions, arrays, objects)
Computer with Node.js installed
Code editor (VS Code recommended)
Internet connection

No prior backend experience needed

How to Use This Repository

Step 1 - Star and clone

git clone https://github.com/mohin-sheikh/nodejs-learning-path
cd nodejs-learning-path

Step 2 - Start with Session 01

cd 01-introduction-to-nodejs

Step 3 - Read the README.md
Open in your code editor or browser

Step 4 - Code along
Type every example yourself

Step 5 - Do the exercises
Don't skip them

Step 6 - Move to next session
Only after completing the exercises

Folder Structure Explained

nodejs-learning-path/
│
├── 01-introduction-to-nodejs/
│   └── README.md           # Complete session content
│
├── 02-project-setup-and-npm/
│   └── README.md
│
... (sessions 03-29)
│
├── 30-mini-project/
│   └── README.md           # Complete project code
│
└── README.md               # Main overview (this document)

Each README.md contains everything for that session

No need to search multiple files

Why This Works

Structured progression
Each session builds on the previous one

Hands-on learning
You write code from session 1

Real projects
Not isolated examples

Complete context
Why, what, and how for each concept

Practice reinforced
Exercises after every session

Success Path

Week 1-2 - Sessions 01-10 (Node.js Basics + Core Modules)
Week 3-4 - Sessions 11-15 (Express + REST APIs)
Week 5-6 - Sessions 16-20 (MongoDB + Database)
Week 7-8 - Sessions 21-25 (Authentication + Advanced)
Week 9-10 - Sessions 26-30 (Production + Mini Project)

Links

GitHub Repository - https://github.com/mohin-sheikh/nodejs-learning-path

Star to save and support

Fork to track your progress

Issues for questions or problems

Share With Others

If this helps you, share it with

Friends learning backend development
Your coding bootcamp group
Twitter/X developer community
LinkedIn network
Discord/Telegram coding groups

What Developers Are Saying

"Finally a structured course that doesn't jump around. Each session clearly connects to the next." - Backend Beginner

"The mini project at the end helped me understand how everything fits together. Worth going through all 30 sessions." - Bootcamp Graduate

"Clear explanations, working code, no fluff. Exactly what I needed." - Self-taught Developer

"The interview questions at the end of each session helped me prepare for my first Node.js interview." - Junior Developer

FAQ

Is this really free?
Yes. Completely free. No email signup. No payment.

Do I need to watch videos?
No. Everything is written documentation. Learn at your own pace.

Can I skip sessions?
Not recommended. Each session builds on previous ones.

What if I get stuck?
Review the session again. Search error messages. Open an issue on GitHub.

Can I use this to prepare for interviews?
Yes. Each session has interview questions. Session 30 is a complete project to showcase.

Is MongoDB required?
Yes. Sessions 16-20 cover MongoDB. Free MongoDB Atlas account works.

How long will this take?
30 days at one session per day. Or spread out over 2-3 months.

Author: Mohin Sheikh

Follow me on GitHub for more insights and projects!

Building a Complete CI/CD Pipeline for Node.js TypeScript Project, A Step-by-Step Guide

Mohin Sheikh — Tue, 24 Mar 2026 16:28:22 +0000

Introduction

When I first started learning about CI/CD pipelines, I was overwhelmed by all the moving parts. GitHub Actions, Docker, testing, linting it seemed like a lot to grasp. After spending weeks figuring it all out, I decided to document my journey so others don't have to go through the same confusion.

In this guide, I'll walk you through building a production-ready Node.js TypeScript application with a complete CI/CD pipeline. We'll start from absolutely nothing and end with a fully automated system that tests, builds, and deploys your code automatically.

By the end of this tutorial, you'll have

A Node.js TypeScript project with proper configuration
Automated testing with Jest
Code quality tools (ESLint and Prettier)
Git hooks to catch issues before commits
A GitHub Actions pipeline that runs on every push
Docker containerization
Automatic Docker image publishing

Prerequisites

Before we start, make sure you have

Node.js installed (version 18 or higher)
Git installed
A GitHub account
Basic knowledge of JavaScript/TypeScript
A code editor (VS Code recommended)

Step 1 - Setting Up Your Project

Let's start by creating a new Node.js project and adding TypeScript.

Open your terminal and run these commands:

mkdir node-ts-cicd-demo
cd node-ts-cicd-demo
npm init -y

This creates a basic package.json file. Now, let's install TypeScript and the necessary types:

npm install --save-dev typescript @types/node ts-node nodemon

Create a tsconfig.json file in the root directory:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "commonjs",
    "lib": ["ES2022"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true,
    "moduleResolution": "node"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist", "**/*.test.ts"]
}

This configuration tells TypeScript how to compile our code. We're targeting ES2022 and using CommonJS modules, which works well with Node.js.

Step 2 - Installing Express and Building a Simple API

Let's install Express to create a simple REST API

npm install express
npm install --save-dev @types/express

Now create a src folder and add our application files. Create src/app.ts

import express, { Application, Request, Response, NextFunction } from 'express';

const app: Application = express();

app.use(express.json());

app.get('/health', (_req: Request, res: Response) => {
  res.json({ 
    status: 'OK', 
    timestamp: new Date().toISOString(),
    environment: process.env.NODE_ENV || 'development'
  });
});

app.get('/', (_req: Request, res: Response) => {
  res.json({ message: 'Welcome to Node.js TypeScript CI/CD Demo API' });
});

app.get('/api/users', (req: Request, res: Response) => {
  const { limit } = req.query;
  let users = [
    { id: 1, name: 'John Doe', email: 'john@example.com' },
    { id: 2, name: 'Jane Smith', email: 'jane@example.com' },
  ];

  if (limit && !isNaN(Number(limit))) {
    users = users.slice(0, Number(limit));
  }

  res.json({ users });
});

app.use((err: Error, _req: Request, res: Response, _next: NextFunction) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Something went wrong!' });
});

export default app;

Create src/server.ts to start the server

import app from './app';

const PORT = process.env.PORT || 3000;

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

Add these scripts to your package.json:

{
  "scripts": {
    "start": "node dist/server.js",
    "dev": "nodemon --exec ts-node src/server.ts",
    "build": "tsc"
  }
}

Test your setup by running npm run dev and visiting http://localhost:3000.

Step 3 - Adding Testing with Jest

Testing is crucial for maintaining code quality. Let's set up Jest

npm install --save-dev jest @types/jest ts-jest supertest @types/supertest

Create jest.config.js

module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  roots: ['<rootDir>/src'],
  testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'],
  collectCoverageFrom: [
    'src/**/*.ts',
    '!src/**/*.d.ts',
    '!src/**/__tests__/**',
    '!src/server.ts',
  ],
  coverageThreshold: {
    global: {
      functions: 70,
      lines: 70,
      statements: 70
    }
  },
  coverageReporters: ['text', 'lcov', 'html'],
};

Now create a test file at src/__tests__/app.test.ts

import request from 'supertest';
import app from '../app';

describe('App Tests', () => {
  describe('GET /health', () => {
    it('should return health status', async () => {
      const response = await request(app)
        .get('/health')
        .expect('Content-Type', /json/)
        .expect(200);

      expect(response.body).toHaveProperty('status', 'OK');
      expect(response.body).toHaveProperty('timestamp');
    });
  });

  describe('GET /', () => {
    it('should return welcome message', async () => {
      const response = await request(app)
        .get('/')
        .expect('Content-Type', /json/)
        .expect(200);

      expect(response.body).toHaveProperty(
        'message',
        'Welcome to Node.js TypeScript CI/CD Demo API'
      );
    });
  });

  describe('GET /api/users', () => {
    it('should return list of users', async () => {
      const response = await request(app)
        .get('/api/users')
        .expect('Content-Type', /json/)
        .expect(200);

      expect(response.body).toHaveProperty('users');
      expect(response.body.users).toHaveLength(2);
      expect(response.body.users[0]).toHaveProperty('name', 'John Doe');
    });
  });

  describe('Error Handling', () => {
    it('should handle 404 routes', async () => {
      await request(app)
        .get('/non-existent-route')
        .expect(404);
    });
  });
});

Add test scripts to package.json

{
  "scripts": {
    "test": "jest",
    "test:watch": "jest --watch",
    "test:coverage": "jest --coverage"
  }
}

Run npm test to verify everything works.

Step 4 - Code Quality with ESLint and Prettier

Consistent code formatting makes your codebase easier to maintain. Let's set up ESLint and Prettier:

npm install --save-dev eslint prettier @typescript-eslint/parser @typescript-eslint/eslint-plugin

Create .eslintrc.json

{
  "parser": "@typescript-eslint/parser",
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/recommended"
  ],
  "parserOptions": {
    "ecmaVersion": 2020,
    "sourceType": "module"
  },
  "env": {
    "node": true,
    "jest": true
  },
  "rules": {
    "no-console": "off",
    "@typescript-eslint/no-unused-vars": ["error", { 
      "argsIgnorePattern": "^_",
      "varsIgnorePattern": "^_" 
    }],
    "@typescript-eslint/explicit-function-return-type": "off",
    "@typescript-eslint/no-explicit-any": "warn"
  }
}

Create .prettierrc

{
  "semi": true,
  "trailingComma": "es5",
  "singleQuote": true,
  "printWidth": 100,
  "tabWidth": 2
}

Create .prettierignore

node_modules
dist
coverage
*.log
.env

Add formatting scripts to package.json

{
  "scripts": {
    "lint": "eslint \"src/**/*.{js,ts}\"",
    "lint:fix": "eslint \"src/**/*.{js,ts}\" --fix",
    "format": "prettier --write \"src/**/*.{js,ts,json}\"",
    "format:check": "prettier --check \"src/**/*.{js,ts,json}\""
  }
}

Run npm run lint and npm run format to see them in action.

Step 5 - Adding Git Hooks with Husky

We want to catch issues before they get committed. Let's add pre-commit hooks

npm install --save-dev husky lint-staged
npx husky init

This creates a .husky folder with a pre-commit hook. Update the pre-commit file at .husky/pre-commit

npx lint-staged

Now add lint-staged configuration to package.json

{
  "lint-staged": {
    "src/**/*.{js,ts}": [
      "eslint --fix",
      "prettier --write"
    ],
    "src/**/*.json": [
      "prettier --write"
    ]
  }
}

Now every time you commit, it will automatically fix formatting and linting issues.

Step 6 - Creating Your GitHub Repository

Create a new repository on GitHub. Don't initialize it with a README or .gitignore. Then push your code:

git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/yourusername/node-ts-cicd-demo.git
git branch -M main
git push -u origin main

Step 7 - Setting Up GitHub Actions

Create the workflow file at .github/workflows/ci-cd.yml

name: CI/CD Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

env:
  NODE_VERSION: '18'

jobs:
  build-and-test:
    name: Build and Test
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: ${{ env.NODE_VERSION }}
        cache: 'npm'

    - name: Install dependencies
      run: npm ci

    - name: Check formatting
      run: npm run format:check

    - name: Lint code
      run: npm run lint

    - name: Build project
      run: npm run build

    - name: Run tests with coverage
      run: npm run test:coverage

  security-scan:
    name: Security Scan
    runs-on: ubuntu-latest
    needs: build-and-test

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Install dependencies
      run: npm ci

    - name: Run npm audit
      run: npm audit --audit-level=moderate || true
      continue-on-error: true

This workflow runs on every push and pull request. It checks formatting, runs linting, builds the project, and runs tests.

Step 8 - Docker Containerization

Create a Dockerfile

FROM node:18-alpine AS builder

WORKDIR /app

COPY package*.json ./
COPY tsconfig.json ./

RUN npm ci

COPY src ./src

RUN npm run build

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./

RUN npm ci --omit=dev --ignore-scripts

COPY --from=builder /app/dist ./dist

RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001 -G nodejs && \
    chown -R nodejs:nodejs /app

USER nodejs

EXPOSE 3000

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node -e "require('http').get('http://localhost:3000/health', (r) => {r.statusCode === 200 ? process.exit(0) : process.exit(1)})"

CMD ["node", "dist/server.js"]

Create .dockerignore

node_modules
npm-debug.log
.git
.gitignore
README.md
.env
coverage
.vscode
*.log

Test your Docker setup locally:

docker build -t node-ts-cicd-demo .
docker run -p 3000:3000 node-ts-cicd-demo

Step 9 - Adding Docker Build to CI/CD

To automatically build and push Docker images, we need to add Docker Hub credentials to GitHub.

First, create a Docker Hub account at hub.docker.com. Then generate a personal access token

Go to Docker Hub Settings
Click "Security" → "New Access Token"
Name it "cicd" and give it Read & Write permissions
Copy the token

Now add secrets to your GitHub repository:

Go to your repository Settings → Secrets and variables → Actions
Add DOCKER_USERNAME with your Docker Hub username
Add DOCKER_PASSWORD with your personal access token

Now update your workflow to include Docker build

  docker-build:
    name: Build and Push Docker Image
    runs-on: ubuntu-latest
    needs: build-and-test
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v3

    - name: Log in to Docker Hub
      uses: docker/login-action@v3
      with:
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}

    - name: Build and push Docker image
      uses: docker/build-push-action@v5
      with:
        context: .
        push: true
        tags: |
          ${{ secrets.DOCKER_USERNAME }}/node-ts-cicd-demo:latest
          ${{ secrets.DOCKER_USERNAME }}/node-ts-cicd-demo:${{ github.sha }}
        cache-from: type=gha
        cache-to: type=gha,mode=max

Step 10 - Handling Common Issues

Throughout this process, I encountered several issues. Here's how to fix them:

ESLint Configuration Error

If you see "ESLint couldn't find a configuration file", make sure your .eslintrc.json is in the root directory and properly formatted.

TypeScript Version Warning

If you see warnings about TypeScript version, downgrade to a compatible version:

npm install --save-dev typescript@5.5.4

Jest Configuration Error

If Jest fails with "export default" error, change your jest.config.js to use CommonJS format:

module.exports = {
  // your config
};

Docker Build Failing with Husky

If Docker fails with "husky not found", add --ignore-scripts to your Dockerfile:

RUN npm ci --omit=dev --ignore-scripts

Docker Hub Authentication Failed

Make sure you're using a personal access token, not your password, and that it has Read & Write permissions.

Step 11 - Testing Your Complete Pipeline

After pushing your code to GitHub, your pipeline will automatically run. Here's what happens

On every push, the build-and-test job runs
It checks code formatting with Prettier
It runs ESLint to catch code issues
It builds the TypeScript code
It runs all tests and checks coverage
On the main branch, it builds a Docker image
It pushes the image to Docker Hub with tags

You can see the entire process in the Actions tab of your GitHub repository.

Step 12 - Deploying Your Application

Now that your Docker image is on Docker Hub, you can deploy it anywhere. Here's a simple way to run it:

docker pull yourusername/node-ts-cicd-demo:latest
docker run -d -p 3000:3000 yourusername/node-ts-cicd-demo:latest

Your application will be running on port 3000. Visit http://localhost:3000/health to see it working.

What We Built

Let's recap everything we accomplished

A TypeScript Node.js application with Express
Automated testing with Jest and Supertest
Code quality tools (ESLint and Prettier)
Git hooks to enforce quality before commits
A GitHub Actions workflow that runs on every push
Security scanning with npm audit
Docker containerization with a production-ready image
Automatic Docker image publishing to Docker Hub

Best Practices We Followed

Throughout this project, we incorporated several best practices:

Version Control - We used Git with meaningful commit messages and proper .gitignore files.

Code Quality - ESLint and Prettier ensure consistent code style and catch common issues.

Testing - We wrote tests for our API endpoints and set coverage thresholds.

Security - We ran security audits and used environment variables for secrets.

Containerization - We created a multi-stage Docker build for smaller, more secure images.

CI/CD - We automated everything so that every push triggers the entire pipeline.

Troubleshooting Guide

Here are solutions to common issues you might encounter

Docker Build Fails - Check your Dockerfile syntax and ensure all required files are present. Use docker build --no-cache to clear any cache issues.

Tests Fail in CI - Run tests locally first. If they pass locally but fail in CI, check for environment differences like line endings or file paths.

ESLint Errors - Run npm run lint:fix to automatically fix common issues. For remaining issues, check the rule documentation.

GitHub Actions Not Triggering - Ensure your workflow file is in the correct directory (.github/workflows/) and has the .yml extension.

Resources for Further Learning

To deepen your understanding, I recommend

TypeScript Handbook for advanced TypeScript features
Jest documentation for more testing patterns
GitHub Actions documentation for custom workflows
Docker best practices guide for optimizing images
ESLint rules documentation for customizing your setup

Project Repository

You can find the complete source code for this project on GitHub

Repository - nodejs-ci-cd-demo

Feel free to clone, fork, or reference it as you follow along with this tutorial.

Complete Project Folder Structure

After following all the steps, your project should have the following structure

nodejs-ci-cd-demo/
│
├── .github/
│   └── workflows/
│       └── ci-cd.yml                 # GitHub Actions CI/CD pipeline
│
├── src/
│   ├── __tests__/
│   │   ├── app.test.ts               # Unit tests for the application
│   │   ├── error-handling.test.ts    # Error handling tests
│   │   ├── logger.test.ts            # Logger utility tests
│   │   └── server.test.ts            # Server tests
│   ├── app.ts                        # Main Express application
│   ├── logger.ts                     # Logger utility
│   └── server.ts                     # Server entry point
│
├── .dockerignore                     # Files to exclude from Docker build
├── .eslintrc.json                    # ESLint configuration
├── .gitignore                        # Git ignore rules
├── .prettierignore                   # Prettier ignore rules
├── .prettierrc                       # Prettier configuration
├── Dockerfile                        # Docker multi-stage build configuration
├── jest.config.js                    # Jest testing configuration
├── package.json                      # Project dependencies and scripts
├── package-lock.json                 # Locked dependency versions
├── tsconfig.json                     # TypeScript compiler options
└── README.md                         # Project documentation

Key Files Explained

.github/workflows/ci-cd.yml - Contains the complete CI/CD pipeline with jobs for building, testing, security scanning, and Docker image publishing.

src/app.ts - The main Express application with API endpoints including health checks, welcome message, and user listing with query parameter support.

Dockerfile - Multi-stage build that compiles TypeScript in one stage and creates a lightweight production image in another.

jest.config.js - Jest configuration with coverage thresholds and test patterns.

tsconfig.json - TypeScript configuration using CommonJS modules for Node.js compatibility.

What's Next?

Now that you have a fully automated CI/CD pipeline, here are some ways to extend this project

Add end-to-end testing with Cypress or Playwright
Implement database integration with PostgreSQL or MongoDB
Add authentication using JWT or OAuth
Set up monitoring with Prometheus and Grafana
Deploy to cloud platforms like AWS ECS, Google Cloud Run, or Azure Container Instances
Add performance testing with Artillery or K6
Implement feature flags for gradual rollouts

Final Thoughts

Building a CI/CD pipeline is one of the most valuable skills a developer can learn. It transforms how you ship code, giving you confidence that every change is tested, validated, and ready for production. The setup we've built today is the same pattern used by companies of all sizes, from startups to large enterprises.

I hope this guide helped you understand not just the "how" but also the "why" behind each tool and configuration. Remember, the best way to learn is to build, break, and fix things. Don't be afraid to experiment with your pipeline, add new features, and make it your own.

If you found this guide helpful, please share it with others who might benefit. Feel free to leave a comment with any questions or suggestions for improvement. Happy coding!

I hope this guide helps you on your journey to building robust, production-ready applications. If you have questions or run into issues, feel free to refer back to this guide or explore the documentation of the tools we used.

Author: Mohin Sheikh

Follow me on GitHub for more insights and projects!

Master Node.js & Express.js: A Comprehensive Collection of Coding Challenges

Mohin Sheikh — Tue, 14 Oct 2025 16:56:52 +0000

Are you looking to level up your JavaScript and Node.js skills? Whether you're a beginner starting your coding journey or an experienced developer wanting to sharpen your backend skills, I've created a comprehensive collection of coding challenges that will take you from fundamentals to advanced concepts through practical, real-world exercises.

Why This Challenge Collection?

This isn't just another tutorial list - it's a structured learning path designed to build your skills progressively. Here's what makes it different:

Progressive Difficulty: Start with basics, end with advanced algorithms
Real-World Scenarios: E-commerce, blog APIs, inventory management
Complete Solutions: Every challenge includes detailed examples
Structured Learning: Numbered files guide your learning journey

What's New in the Collection?

JavaScript Fundamentals (3 Files)

01-basic-javascript-challenges.md

Core JavaScript concepts
Array and string manipulation
Object handling
25 beginner-friendly challenges

02-intermediate-javascript-challenges.md

Advanced array methods
Custom filter/map/reduce implementations
Complex object manipulation
Real-world data processing

03-advanced-javascript-challenges.md

Data structures (LRU Cache, BST, Graphs)
Algorithms (QuickSort, Dijkstra, Binary Search)
Functional programming patterns
Performance optimization

Node.js & Express.js (5 Files)

01-beginner-express-challenges.md

Express server setup and configuration
Basic routing with HTTP methods
URL parameters and query handling

02-express-middleware-challenges.md

Middleware implementation and chaining
Role-based access control
Error handling and validation

03-nodejs-data-manipulation-challenges.md

Data aggregation and transformation
Working with related datasets
Complex data structure handling

04-ecommerce-order-management-challenges.md

Complex data relationships
Customer analytics and reporting
Order processing systems

05-express-blog-api-challenges.md

RESTful API design principles
HTTP status code usage
Production-ready API development

Quick Start Guide

Prerequisites

Node.js (v14 or higher)
Basic JavaScript knowledge
Code editor (VS Code recommended)

Setup in 2 Minutes

# Clone the repository
git clone https://github.com/mohin-sheikh/js-node-coding-questions.git
cd js-node-coding-questions

# Initialize your project
npm init -y
npm install express

# Create server file
touch index.js

Basic Server Template

const express = require('express');
const app = express();
const PORT = 3000;

app.use(express.json());

// Your routes go here

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

Structured Learning Path

Phase 1: JavaScript Foundation (3-4 weeks)

Start with basic JavaScript challenges to build solid fundamentals before moving to backend development.

Phase 2: Backend Development (8-10 weeks)

Progress through Express.js basics, middleware, data manipulation, and real-world applications.

Phase 3: Mastery (4-6 weeks)

Tackle advanced algorithms, data structures, and complex system design.

Real Projects You'll Build

E-commerce Analytics System: Process orders, calculate revenue, analyze customer behavior
Blog API with Comments: Full CRUD operations, search, pagination
Inventory Management: Track stock, generate reports, handle low inventory
Financial Analytics: Transaction processing, category-wise spending reports
Employee Management System: Department analytics, skill gap analysis

Testing Your Solutions

Use these tools to verify your work:

# Test JavaScript functions
node -e "console.log(require('./your-solution.js').yourFunction())"

# Test API endpoints
curl http://localhost:3000/api/posts

# Test with authentication
curl -H "Authorization: Bearer token" http://localhost:3000/api/users

Key Skills You'll Master

Technical Skills

Express.js routing and middleware
RESTful API design and development
Data structures and algorithms
Error handling and validation
Performance optimization

Problem-Solving Skills

Breaking down complex problems
Algorithmic thinking
System design principles
Code optimization techniques

Success Stories from Learners

"The progressive structure helped me go from JavaScript basics to building full APIs in 2 months!" - Frontend Developer transitioning to Full Stack

"The real-world scenarios prepared me perfectly for technical interviews." - Recent Bootcamp Graduate

"Finally found a resource that covers everything from arrays to advanced algorithms!" - Self-Taught Developer

Pro Tips for Maximum Impact

Code Daily: Even 30 minutes daily beats 4 hours once a week
Understand Don't Memorize: Focus on the 'why' behind solutions
Build Projects: Apply concepts to personal projects
Review Regularly: Revisit previous challenges to reinforce learning
Join Community: Discuss solutions and learn from others

Get Started Today

Repository: github.com/mohin-sheikh/js-node-coding-questions

Your First Week Plan

Day 1-2: Complete basic JavaScript challenges
Day 3-4: Set up Express server and basic routes
Day 5-7: Build your first API endpoint

For Experienced Developers

Skip to intermediate/advanced challenges that match your current level and focus on gaps in your knowledge.

Continuous Updates

The repository is actively maintained with:

New challenges added regularly
Community contributions welcomed
Solutions improved based on feedback
Additional learning resources

Ready to Transform Your Skills?

This collection represents hundreds of hours of curated content designed to take you from wherever you are now to JavaScript and Node.js mastery.

Start today with the first challenge and commit to completing one challenge daily. In 2-3 months, you'll have the skills to build complex backend systems and ace technical interviews.

Share Your Journey

I'd love to see your progress! Share your solutions, ask questions, and connect with other learners through the repository's discussion section.

What's the biggest challenge you're facing in learning Node.js? Share in the comments below!

Follow me on GitHub for more learning resources and updates on new challenges!

JavaScript Learning Journey From Basics to Advanced

Mohin Sheikh — Thu, 09 Oct 2025 11:51:46 +0000

A comprehensive, structured roadmap to master JavaScript programming from fundamentals to advanced concepts. Designed specifically for beginners starting their web development career.

Repository Overview

This repository provides a carefully structured learning path that breaks down complex JavaScript concepts into digestible, practical lessons. Each module builds upon the previous one, ensuring a smooth learning curve with hands-on examples and real-world applications.

Structured Learning Path

Foundation Series (Start Here)

Module	Topic	Focus Areas
01	JavaScript Introduction	Setup, syntax, first program
02	Variables & Scope	let, const, var, scope chains
03	Data Types	Primitives, objects, type checking
04	Template Literals & Operators	String interpolation, operators
05	String Methods	String manipulation methods
06	Objects & CRUD	Object creation, manipulation
07	Shallow & Deep Copy	Reference vs value, cloning
08	Functions & Types	Function declarations, expressions
09	Arrays & Methods	Array manipulation, methods
10	Timing Events	setTimeout, setInterval
11	Callback Functions	Callback patterns, async basics
12	Promises Complete Guide	Promise chains, error handling
13	ES6+ Features	Modern JavaScript features
14	Constructors & Classes	Object-oriented programming
15	Closures Simple Guide	Understanding closures
16	For Loops Simple Guide	Loop structures and patterns
17	For...in & For...of Loops	Object and array iteration
18	Math Methods	Comprehensive guide to Math methods

Intermediate Series (Coming Soon)

DOM Manipulation
Event Handling
API Integration
Error Handling
Modules and Import/Export

Advanced Series (Coming Soon)

Async/Await
Design Patterns
Performance Optimization
Modern Frameworks Preparation

Key Features

Progressive Learning → Step-by-step progression from basic to advanced topics
Practical Examples → Real-world code examples with detailed explanations
Beginner Focused → No prior programming experience required
Hands-on Approach → Emphasis on writing code and experimentation
Comprehensive Coverage → From variables to advanced asynchronous programming

How to Use This Repository

Getting Started

Begin with Module 01 and progress sequentially through each topic
Type all code examples manually to build muscle memory
Experiment with modifying examples to test your understanding
Complete each module before moving to the next

Learning Methodology

Read the Theory → Understand the concept being explained
Code Along → Type every example in your development environment
Experiment → Modify parameters and observe changes
Practice → Solve additional problems using the same concepts
Review → Revisit previous topics to reinforce learning

Learning Principles

Core Principles

Consistency Over Intensity → Regular practice beats cramming
Build Foundations First → Master basics before advancing
Learn by Doing → Active coding trumps passive reading
Embrace Challenges → Struggle is part of the learning process

Study Tips

Code for at least 30 minutes daily
Keep a programming journal for notes and insights
Build small projects after each major section
Join coding communities for support and guidance
Don't hesitate to revisit previous topics when needed

Prerequisites

Basic computer literacy
Text editor (VS Code recommended)
Web browser
No prior programming experience required

Support Resources

All code examples are tested and working
Clear explanations for each concept
Progressive difficulty building
Practical application focus

Troubleshooting Guide

If stuck on a concept, take a break and return later
Google error messages for additional insights
Compare your code with provided examples
Practice the same concept with different examples
Remember that debugging is a valuable skill to develop

Career Path

This learning path prepares you for →

Frontend Developer roles
Full-stack JavaScript development
Modern framework learning (React, Vue, Angular)
Backend Node.js development
Technical interviews and coding assessments

Start your journey with Module 01: JavaScript Introduction and begin building your programming foundation today!

Author: Mohin Sheikh

Connect on GitHub for more learning resources and updates!

Repository: JavaScript Basics to Advanced

What is a POC (Proof of Concept) in Development? + A Beginner-Friendly Node.js Example

Mohin Sheikh — Wed, 21 May 2025 07:39:07 +0000

Introduction

When starting a new software project or implementing a new feature, you'll often hear the term POC or Proof of Concept. But what exactly is a POC in software development, and why is it important?

In this article, we’ll dive into:

What is a POC?
Why and when you should create one
Benefits of building a POC
A real-world example using Node.js that even beginners can understand!

What is a POC?

POC (Proof of Concept) is a small prototype or a minimal implementation of a feature or technology to test if something is technically feasible before investing full time and resources into building it.

It's not the final product. It’s a quick check: “Can we do this at all?”

Why Do Developers Create POCs?

To validate an idea or approach before building the full solution
To check if a technology or service fits into the project
To reduce the risk of failure or wasted time
To communicate feasibility to stakeholders, team members, or clients

Characteristics of a Good POC

Small and focused
No full UI/UX, just enough to prove it works
May use dummy data or hardcoded values
Doesn’t focus on optimization or scalability
Can be thrown away after it proves the concept

Real Example: Building a POC in Node.js

Scenario

Let’s say you want to test whether sending emails using Node.js and a package like Nodemailer is possible in your project.

Rather than building a full email feature with user accounts, password resets, etc., you decide to write a POC script that:

Sends a test email using Gmail
Confirms that the service works

Node.js POC: Send Email with Nodemailer

Step 1: Initialize the Project

mkdir email-poc
cd email-poc
npm init -y
npm install nodemailer dotenv

Step 2: Create `.env` file to store credentials

EMAIL_USER=your-email@gmail.com
EMAIL_PASS=your-app-password

Use App Passwords for Gmail if 2FA is enabled. Never use your real password.

Step 3: Create `sendEmail.js`

require('dotenv').config();
const nodemailer = require('nodemailer');

async function sendTestEmail() {
  try {
    const transporter = nodemailer.createTransport({
      service: 'gmail',
      auth: {
        user: process.env.EMAIL_USER,
        pass: process.env.EMAIL_PASS,
      },
    });

    const mailOptions = {
      from: process.env.EMAIL_USER,
      to: 'recipient@example.com',
      subject: 'POC Test Email',
      text: 'Hello! This is a test email from my Node.js POC.',
    };

    const info = await transporter.sendMail(mailOptions);
    console.log('✅ Email sent: ', info.response);
  } catch (error) {
    console.error('❌ Error sending email: ', error.message);
  }
}

sendTestEmail();

Step 4: Run the Script

node sendEmail.js

You should see a message like:

Email sent: 250 2.0.0 OK

If it works—congratulations! You just built a POC to prove you can send emails using Node.js and Nodemailer. 🎉

What Next?

Now that you’ve proven the concept works, you can:

Integrate email logic in a full backend project
Add templates, user emails, and dynamic content
Implement proper logging, error handling, and retries

Final Thoughts

A POC is not production code — it’s like a scientific experiment: just enough to test an idea.
Don’t overengineer it.
Once it works, you can throw it away or use it as a base for the final version.

Who Should Use POCs?

Beginners trying out a new package or technology
Startups testing product features
Developers working on unfamiliar tools
Teams exploring third-party integrations

Summary

Concept	Description
POC	Small prototype to test feasibility
Use Case	Test sending emails via Node.js
Tools Used	Nodemailer, dotenv, Gmail
Outcome	Validated that sending email is possible ✅

Have You Built a POC Before?

Let me know in the comments what POCs you've built or are thinking of building!

If this helped you, leave a ❤️ or 🦄!

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Cron Jobs in Node.js: A Complete Guide for Backend Developers

Mohin Sheikh — Wed, 21 May 2025 07:22:12 +0000

What Are Cron Jobs in Node.js?
Approaches to Cron Jobs in Node.js
Using System-Level Cron Jobs
Using node-cron npm Package
Advanced: Job Scheduling with agenda
Common Use Cases
Troubleshooting
Best Practices

1. What Are Cron Jobs in Node.js?

Cron jobs let you execute functions or scripts at specific intervals (e.g., every minute, hourly, daily). In Node.js, you can:

Use system-level cron (via crontab).
Use in-process schedulers (npm packages like node-cron or agenda).

2. Approaches to Cron Jobs in Node.js

Method	Pros	Cons
System Cron	Simple, OS-managed, survives app crashes	Requires shell access, harder to debug
`node-cron`	Easy in-app scheduling, JS syntax	Tied to app lifecycle (stops if app crashes)
`agenda`	Persistent jobs, retries, MongoDB support	Requires MongoDB, more complex setup

3. Using System-Level Cron Jobs

Step 1: Create a Node.js Script

// scripts/cleanup.js
console.log('Cleaning up database at', new Date().toISOString());
// Add your logic here

Step 2: Make the Script Executable

chmod +x scripts/cleanup.js

Step 3: Schedule with Crontab

Edit your crontab:

crontab -e

Add a job (use the full path to Node.js and your script):

# Run every day at 2:30 AM
30 2 * * * /usr/local/bin/node /home/user/app/scripts/cleanup.js >> /var/log/cron.log 2>&1

Key Notes:

Find your Node.js path with which node (e.g., /usr/local/bin/node).
Use absolute paths for scripts and output files.
Log output to debug issues (>> /var/log/cron.log 2>&1).

4. Using `node-cron` npm Package

Ideal for in-app scheduling without relying on system cron.

Installation

npm install node-cron

Basic Usage

const cron = require('node-cron');

// Run every minute
cron.schedule('* * * * *', () => {
  console.log('Running task every minute:', new Date().toISOString());
});

Advanced Example (with Timezone)

const cron = require('node-cron');

// Run daily at 8:00 AM in Europe/London timezone
cron.schedule('0 8 * * *', () => {
  console.log('Sending morning report...');
}, {
  scheduled: true,
  timezone: 'Europe/London'
});

Schedule Syntax Cheatsheet

Pattern	Description
`/5 * * *`	Every 5 minutes
`0 9 * * 1-5`	Weekdays at 9:00 AM
`0 0 1 * *`	First day of the month at midnight

5. Advanced: Job Scheduling with `agenda`

For persistent, retriable jobs (requires MongoDB).

Installation

npm install agenda

Setup

const Agenda = require('agenda');
const agenda = new Agenda({ db: { address: 'mongodb://localhost:27017/agenda' } });

// Define a job
agenda.define('send-email', async (job) => {
  const { userId } = job.attrs.data;
  console.log(`Sending email to user ${userId}`);
  // Add your email logic here
});

// Schedule job to run every 2 hours
agenda.every('2 hours', 'send-email', { userId: 123 });

// Start agenda
(async () => {
  await agenda.start();
})();

Key Features:

Persistent jobs: Survive app restarts.
Retries: Automatically retry failed jobs.
Flexible scheduling: Use cron syntax or human-readable intervals.

6. Common Use Cases

1. Database Cleanup (Expired Tokens)

// Using node-cron
cron.schedule('0 0 * * *', async () => {
  await Token.deleteMany({ expiresAt: { $lt: new Date() } });
});

2. Send Daily Reports via Email

// Using agenda
agenda.define('daily-report', async () => {
  const users = await User.find({ wantsReport: true });
  users.forEach(user => sendEmail(user.email, 'Your daily report!'));
});

agenda.every('0 9 * * *', 'daily-report');

3. Cache Invalidation

// Every 10 minutes
cron.schedule('*/10 * * * *', () => {
  cache.clearExpired();
});

4. Poll External APIs

// Poll every 5 minutes
cron.schedule('*/5 * * * *', async () => {
  const data = await fetch('https://api.example.com/data');
  await processData(data);
});

7. Troubleshooting

Common Issues & Fixes:

Cron job not running:
- Check if the Node process is running (for node-cron/agenda).
- For system cron, check logs: grep CRON /var/log/syslog.
Module not found:
- Use absolute paths in scripts.
- Install dependencies globally if needed (not recommended).
Permissions issues:
- Ensure the cron user has execute access: chmod +x your-script.js.
Timezone mismatches:
- Use the timezone option in node-cron or set TZ in your OS.

Debugging Tips:

Log everything:

  cron.schedule('* * * * *', () => {
    console.log('Cron job started at', new Date());
    try {
      // Your logic here
    } catch (err) {
      console.error('Cron job failed:', err);
    }
  });

Test with shorter intervals first (e.g., every minute).

8. Best Practices

1. Use Task Queues for Heavy Work

Offload CPU-heavy tasks to worker threads:

const { Worker } = require('worker_threads');

cron.schedule('0 * * * *', () => {
  const worker = new Worker('./path/to/worker.js');
});

2. Handle Failures Gracefully

// With agenda (automatic retries)
agenda.define('critical-job', { concurrency: 1, maxAttempts: 3 }, async (job) => {
  // Your logic
});

// With node-cron
cron.schedule('...', async () => {
  try {
    await criticalTask();
  } catch (err) {
    sendAlertToSlack('Cron job failed: ' + err.message);
  }
});

3. Avoid Overlapping Jobs

Use agenda’s concurrency control or a locking mechanism:

let isJobRunning = false;

cron.schedule('*/5 * * * *', async () => {
  if (isJobRunning) return;
  isJobRunning = true;
  await longRunningTask();
  isJobRunning = false;
});

4. Use Environment-Specific Schedules

Disable cron jobs in development:

// In your Node.js app
if (process.env.NODE_ENV === 'production') {
  cron.schedule('...', productionTask);
}

5. Monitor Your Jobs

Log job start/end times.
Use tools like PM2 for process management:

  pm2 start app.js
  pm2 logs

Final Thoughts

Choose system cron if:

You need tasks to run independently of your Node app.
Your hosting provider supports crontab.

Choose node-cron if:

You prefer keeping jobs within your codebase.
You need simple in-app scheduling.

Choose agenda if:

You require job persistence and retries.
Your app already uses MongoDB.

By combining these tools with proper error handling and monitoring, you can build robust automated workflows for your Node.js backend. Happy coding! 🚀

Further Resources:

Author: Mohin Sheikh

Follow me on GitHub for more insights!

From JavaScript to Python: A Syntax Guide for Developers

Mohin Sheikh — Mon, 19 May 2025 13:20:30 +0000

Introduction

If you’re a JavaScript developer diving into Python, you’ll find many concepts familiar but with syntactic twists. Python’s emphasis on readability and simplicity means fewer brackets, strict indentation, and a different approach to common tasks. Let’s break down key differences with side-by-side examples.

1. Variables and Constants

JavaScript

let mutableVar = 10;       // Mutable
const immutableVar = 20;   // Immutable

Python

mutable_var = 10    # No 'let' or 'const'—all variables are mutable
IMMUTABLE_VAR = 20  # Convention: UPPER_CASE for "constants" (not enforced)

Key Notes:

Python uses snake_case (not camelCase).
No var or const—just assign values.

2. Data Types

JavaScript	Python	Notes
`number`	`int`, `float`	Python distinguishes integers and floats.
`string`	`str`	Both use template literals/f-strings.
`boolean` (lowercase)	`bool` (TitleCase)	Python: `True/False` (case-sensitive).
`array`	`list`, `tuple`	Lists are mutable; tuples are immutable.
`object`	`dict`	Python dicts ≈ JS objects.
`null`/`undefined`	`None`	Python’s universal "no value" placeholder.

3. Conditionals

JavaScript

if (age > 18) {
  console.log("Adult");
} else if (age === 18) {
  console.log("Exactly 18");
} else {
  console.log("Minor");
}

Python

if age > 18:
    print("Adult")
elif age == 18:    # 'elif' instead of 'else if'
    print("Exactly 18")
else:
    print("Minor")   # Indentation defines blocks (no curly braces!)

Gotchas:

Use == for equality checks (Python has no ===).
Indentation is mandatory—use 4 spaces (no tabs).

4. Loops

For Loop

JavaScript (C-style):

for (let i = 0; i < 5; i++) {
  console.log(i);
}

Python (range-based):

for i in range(5):   # range(0, 5) → 0,1,2,3,4
    print(i)

Iterating Over Arrays/Lists

JavaScript:

const fruits = ["apple", "banana"];
for (const fruit of fruits) {
  console.log(fruit);
}

Python:

fruits = ["apple", "banana"]
for fruit in fruits:
    print(fruit)

5. Functions

JavaScript

function multiply(a, b) {
  return a * b;
}
// Arrow function
const multiply = (a, b) => a * b;

Python

def multiply(a, b):
    return a * b

# Lambda (anonymous)
multiply = lambda a, b: a * b

Key Differences:

Python uses def instead of function.
Lambdas are limited to single expressions.

6. Strings

Template Literals (JS) vs. f-Strings (Python)

JavaScript:

const name = "Alice";
console.log(`Hello, ${name}!`);  // Backticks

Python:

name = "Alice"
print(f"Hello, {name}!")  # 'f' prefix

7. Arrays (JS) vs. Lists (Python)

Action	JavaScript	Python
Add element	`arr.push(4)`	`lst.append(4)`
Remove last	`arr.pop()`	`lst.pop()`
Check existence	`arr.includes(4)`	`4 in lst`
Create copy	`[...arr]`	`lst.copy()`
Map	`arr.map(x => x*2)`	`[x*2 for x in lst]`

Python List Comprehension Example:

squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

8. Objects (JS) vs. Dictionaries (Python)

JavaScript:

const user = { 
  name: "Alice", 
  age: 30 
};
console.log(user.name);  // Dot notation

Python:

user = {
    "name": "Alice",
    "age": 30
}
print(user["name"])   # Or user.get("name")

9. Classes

JavaScript

class Dog {
  constructor(name) {
    this.name = name;
  }

  bark() {
    console.log("Woof!");
  }
}

Python

class Dog:
    def __init__(self, name):  # Constructor
        self.name = name

    def bark(self):            # 'self' is explicit
        print("Woof!")

Key Notes:

Python requires self as the first method parameter.
No new keyword: my_dog = Dog("Buddy").

10. Error Handling

JavaScript:

try {
  throw new Error("Failed!");
} catch (error) {
  console.log(error.message);
}

Python:

try:
    raise Exception("Failed!")
except Exception as e:
    print(e)

11. Modules and Imports

JavaScript (ES6):

import React from 'react';
export const PI = 3.14;

Python:

import math
from math import sqrt

# Exporting: Just write variables/functions in the file.
PI = 3.14

12. Truthy and Falsy Values

JavaScript Falsy	Python Falsy
`false`, `0`, `""`	`False`, `0`, `""`
`null`, `undefined`	`None`
`NaN`	`[]`, `{}`, `()`

Example:

if not []:   # Empty list is falsy
    print("This list is empty!")

Key Takeaways

Indentation Rules: Python uses indentation (4 spaces) instead of curly braces.
Simplicity: Python favors explicit, readable code (e.g., elif over else if).
Rich Data Structures: Lists, tuples, sets, and dictionaries offer flexibility.
No Semicolons: Optional in Python (but avoid them).

Example: Factorial Function

JavaScript:

function factorial(n) {
  if (n === 0) return 1;
  return n * factorial(n - 1);
}

Python:

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

Next Steps

Practice: Use platforms like LeetCode to solve problems in Python.
Explore Libraries: Learn numpy (arrays), pandas (dataframes), and requests (HTTP).
Read the Zen of Python: Run import this in a Python shell.

Final Thoughts

Python’s syntax feels minimalist compared to JavaScript, but its strict structure encourages clean code. Start small, embrace indentation, and leverage Python’s powerful built-in tools.

Happy coding! 🐍

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Writing Unit Tests for an Express.js Application: A Beginner-Friendly Guide

Mohin Sheikh — Wed, 25 Dec 2024 08:13:14 +0000

📖 Table of Contents

Introduction to Unit Testing
Why Unit Testing is Important
Setting Up the Testing Environment
Installing Testing Dependencies
Project Structure for Testing
Writing Unit Tests for Controllers
Writing Unit Tests for Middleware
Writing Unit Tests for Services
Running Unit Tests
Best Practices for Unit Testing
Conclusion

1. Introduction to Unit Testing

Unit testing involves testing individual units or components of an application in isolation to ensure they work as expected. In Express.js, unit tests typically focus on testing controllers, middlewares, and services.

2. Why Unit Testing is Important

Detects bugs early in development.
Ensures code behaves as expected.
Makes refactoring easier.
Improves code maintainability.
Provides documentation for how the code should work.

3. Setting Up the Testing Environment

Ensure your Express.js application is set up and functional.

If not, follow the Setup Guide.

4. Installing Testing Dependencies

Install the required testing libraries:

npm install --save-dev jest ts-jest @types/jest supertest @types/supertest

jest: Testing framework.
ts-jest: Jest configuration for TypeScript.
supertest: Library for testing HTTP APIs.

4.1 Configure Jest

Create a jest.config.ts file in your project root:

export default {
  preset: 'ts-jest',
  testEnvironment: 'node',
  moduleNameMapper: {
    '^@/(.*)$': '<rootDir>/src/$1',
  },
  moduleFileExtensions: ['ts', 'js', 'json'],
  testMatch: ['**/__tests__/**/*.test.ts'],
};

Add a test script to your package.json:

{
  "scripts": {
    "test": "jest --coverage"
  }
}

5. Project Structure for Testing

src/
├── controllers/
│   ├── userController.ts
├── services/
│   ├── userService.ts
├── middleware/
│   ├── authMiddleware.ts
└── __tests__/
    ├── controllers/
    │   ├── userController.test.ts
    ├── services/
    │   ├── userService.test.ts
    ├── middleware/
        ├── authMiddleware.test.ts

6. Writing Unit Tests for Controllers

6.1 Example Controller

File: src/controllers/userController.ts

import { Request, Response } from 'express';

export const getUser = (req: Request, res: Response) => {
  res.status(200).json({ id: 1, name: 'John Doe' });
};

6.2 Test Controller

File: src/__tests__/controllers/userController.test.ts

import { getUser } from '../../controllers/userController';
import { Request, Response } from 'express';

describe('User Controller - getUser', () => {
  it('should return user data with status 200', () => {
    const req = {} as Request;
    const res = {
      status: jest.fn().mockReturnThis(),
      json: jest.fn(),
    } as unknown as Response;

    getUser(req, res);

    expect(res.status).toHaveBeenCalledWith(200);
    expect(res.json).toHaveBeenCalledWith({ id: 1, name: 'John Doe' });
  });
});

Explanation:

Mocked Request and Response.
Called the getUser controller function.
Asserted status code and response data.

7. Writing Unit Tests for Middleware

7.1 Example Middleware

File: src/middleware/authMiddleware.ts

import { Request, Response, NextFunction } from 'express';

export const isAuthenticated = (req: Request, res: Response, next: NextFunction) => {
  if (req.headers.authorization === 'Bearer validToken') {
    next();
  } else {
    res.status(403).json({ message: 'Forbidden' });
  }
};

7.2 Test Middleware

File: src/__tests__/middleware/authMiddleware.test.ts

import { isAuthenticated } from '../../middleware/authMiddleware';
import { Request, Response, NextFunction } from 'express';

describe('Auth Middleware - isAuthenticated', () => {
  it('should call next if token is valid', () => {
    const req = { headers: { authorization: 'Bearer validToken' } } as Request;
    const res = {} as Response;
    const next = jest.fn();

    isAuthenticated(req, res, next);

    expect(next).toHaveBeenCalled();
  });

  it('should return 403 if token is invalid', () => {
    const req = { headers: { authorization: '' } } as Request;
    const res = {
      status: jest.fn().mockReturnThis(),
      json: jest.fn(),
    } as unknown as Response;
    const next = jest.fn();

    isAuthenticated(req, res, next);

    expect(res.status).toHaveBeenCalledWith(403);
    expect(res.json).toHaveBeenCalledWith({ message: 'Forbidden' });
  });
});

8. Writing Unit Tests for Services

8.1 Example Service

File: src/services/userService.ts

export const findUserById = (id: number) => {
  if (id === 1) {
    return { id: 1, name: 'John Doe' };
  }
  return null;
};

8.2 Test Service

File: src/__tests__/services/userService.test.ts

import { findUserById } from '../../services/userService';

describe('User Service - findUserById', () => {
  it('should return user data when valid ID is provided', () => {
    const user = findUserById(1);
    expect(user).toEqual({ id: 1, name: 'John Doe' });
  });

  it('should return null when invalid ID is provided', () => {
    const user = findUserById(2);
    expect(user).toBeNull();
  });
});

9. Running Unit Tests

Run your tests with:

npm run test

Sample Output:

 PASS  __tests__/controllers/userController.test.ts
 PASS  __tests__/middleware/authMiddleware.test.ts
 PASS  __tests__/services/userService.test.ts

Test Suites: 3 passed, 3 total
Tests:       6 passed, 6 total
Snapshots:   0 total
Time:        2.345 s

Check Test Coverage

npm run test -- --coverage

10. Best Practices for Unit Testing

Test one functionality per test case.
Mock external dependencies (e.g., database calls).
Ensure your tests are independent and isolated.
Use descriptive describe and it blocks.
Avoid testing implementation details.
Include edge cases in your tests.

11. Conclusion

Unit testing validates each part of your Express.js app independently.
Focus on Controllers, Middleware, and Services.
Use Jest and Supertest for efficient testing.

✨ Your Express.js application now has comprehensive unit tests! 🚀

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Adding Authentication to an Express.js Application with JWT: A Beginner-Friendly Guide

Mohin Sheikh — Wed, 25 Dec 2024 08:08:02 +0000

📖 Table of Contents

Introduction to Authentication
What is JWT (JSON Web Token)?
Setting Up the Project
Installing Dependencies
Creating a User Model
Setting Up JWT Authentication Middleware
Creating Authentication Routes (Login, Register, Protected Route)
Testing the Authentication System
Environment Variables for Security
Best Practices for Authentication
Conclusion

1. Introduction to Authentication

Authentication ensures that only verified users can access certain resources in your application. In this guide, we’ll use JWT (JSON Web Token) for secure authentication in an Express.js application.

2. What is JWT (JSON Web Token)?

JWT is an open standard (RFC 7519) for securely transmitting information between parties as a JSON object.
Tokens are signed using a secret key or a public/private key pair.

Structure of a JWT Token:

Header.Payload.Signature

Header: Metadata about the token.
Payload: User data and claims.
Signature: Verifies the integrity of the token.

3. Setting Up the Project

Ensure you have a basic Express.js application ready. If not, follow this guide.

Initialize a new Node.js project:

npm init -y
npm install express jsonwebtoken bcryptjs dotenv

4. Installing Dependencies

express: Web framework for Node.js.
jsonwebtoken: Handles JWT generation and verification.
bcryptjs: Hashes passwords securely.
dotenv: Loads environment variables.

Install all dependencies:

npm install express jsonwebtoken bcryptjs dotenv
npm install --save-dev @types/jsonwebtoken @types/bcryptjs

5. Creating a User Model

For MongoDB:

File: src/models/userModel.ts

import mongoose, { Schema, Document } from 'mongoose';

interface IUser extends Document {
  username: string;
  email: string;
  password: string;
}

const UserSchema: Schema = new Schema({
  username: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true },
});

export default mongoose.model<IUser>('User', UserSchema);

For PostgreSQL:

File: src/models/userModel.ts

import db from '../config/knex';

export const createUser = (user: { username: string; email: string; password: string }) => db('users').insert(user);
export const getUserByEmail = (email: string) => db('users').where({ email }).first();

6. Setting Up JWT Authentication Middleware

File: src/middleware/authMiddleware.ts

import jwt from 'jsonwebtoken';
import { Request, Response, NextFunction } from 'express';

interface AuthRequest extends Request {
  user?: any;
}

export const authenticateJWT = (req: AuthRequest, res: Response, next: NextFunction) => {
  const token = req.header('Authorization')?.split(' ')[1];

  if (!token) {
    return res.status(403).json({ message: 'Authorization required' });
  }

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET || '');
    req.user = decoded;
    next();
  } catch (error) {
    res.status(401).json({ message: 'Invalid Token' });
  }
};

7. Creating Authentication Routes (Login, Register, Protected Route)

7.1 Register Route

File: src/controllers/authController.ts

import bcrypt from 'bcryptjs';
import jwt from 'jsonwebtoken';
import User from '../models/userModel';
import { Request, Response } from 'express';

export const registerUser = async (req: Request, res: Response) => {
  const { username, email, password } = req.body;

  const hashedPassword = await bcrypt.hash(password, 10);

  const newUser = new User({ username, email, password: hashedPassword });
  await newUser.save();

  res.status(201).json({ message: 'User registered successfully' });
};

7.2 Login Route

export const loginUser = async (req: Request, res: Response) => {
  const { email, password } = req.body;

  const user = await User.findOne({ email });
  if (!user) {
    return res.status(400).json({ message: 'Invalid credentials' });
  }

  const isPasswordValid = await bcrypt.compare(password, user.password);
  if (!isPasswordValid) {
    return res.status(400).json({ message: 'Invalid credentials' });
  }

  const token = jwt.sign({ id: user._id, email: user.email }, process.env.JWT_SECRET || '', { expiresIn: '1h' });
  res.json({ token });
};

7.3 Protected Route

export const protectedRoute = async (req: any, res: Response) => {
  res.json({ message: `Hello, ${req.user.email}! You have access.` });
};

7.4 Authentication Routes

File: src/routes/authRoutes.ts

import express from 'express';
import { registerUser, loginUser, protectedRoute } from '../controllers/authController';
import { authenticateJWT } from '../middleware/authMiddleware';

const router = express.Router();

router.post('/register', registerUser);
router.post('/login', loginUser);
router.get('/protected', authenticateJWT, protectedRoute);

export default router;

7.5 Update `app.ts`

import authRoutes from './routes/authRoutes';

app.use('/api/auth', authRoutes);

8. Testing the Authentication System

8.1 Register a User

Endpoint: POST /api/auth/register
Request Body:

{
  "username": "testuser",
  "email": "test@example.com",
  "password": "password123"
}

Response:

{
  "message": "User registered successfully"
}

8.2 Login User

Endpoint: POST /api/auth/login
Request Body:

{
  "email": "test@example.com",
  "password": "password123"
}

Response:

{
  "token": "JWT_TOKEN_HERE"
}

8.3 Access Protected Route

Endpoint: GET /api/auth/protected
Header:

Authorization: Bearer JWT_TOKEN_HERE

Response:

{
  "message": "Hello, test@example.com! You have access."
}

9. Environment Variables for Security

File: .env

JWT_SECRET=your_jwt_secret_key

Ensure you keep this secret key secure and never expose it publicly.

10. Best Practices for Authentication

Always hash passwords using bcrypt.
Store JWT secrets securely in .env.
Use short expiration times for tokens.
Implement refresh tokens for better security.
Avoid sending sensitive data in JWT payloads.

11. Conclusion

Authentication Flow: User registration → Login → JWT Token Generation → Access Protected Routes.
JWT is stateless and scalable for modern applications.
Secure your routes using middleware.

✨ Your Express.js app now has JWT-based authentication! 🚀

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Connecting an Express.js Application to MongoDB and PostgreSQL: A Step-by-Step Guide for Beginners

Mohin Sheikh — Wed, 25 Dec 2024 08:03:15 +0000

📖 Table of Contents

Introduction to Databases
MongoDB vs PostgreSQL: Key Differences
Setting Up MongoDB
Connecting MongoDB to Express.js
Setting Up PostgreSQL
Connecting PostgreSQL to Express.js
Implementing CRUD Operations with a Database
Environment Variables for Database Configuration
Best Practices
Conclusion

1. Introduction to Databases

Databases are essential for any web application to store, retrieve, and manage data efficiently.

MongoDB: A NoSQL database that stores data in JSON-like documents. Great for unstructured data.
PostgreSQL: A relational SQL database ideal for structured data with complex relationships.

2. MongoDB vs PostgreSQL: Key Differences

Feature	MongoDB	PostgreSQL
Type	NoSQL	SQL
Schema	Flexible	Fixed Schema
Scalability	Horizontal	Vertical
Best for	Real-time apps, Document storage	Complex queries, Structured data

Choose MongoDB for flexibility and PostgreSQL for structured and relational data.

3. Setting Up MongoDB

3.1 Install MongoDB Locally

Download MongoDB from the official MongoDB website.
Install MongoDB Compass (GUI tool for MongoDB).

3.2 Set Up MongoDB Connection URL

MONGODB_URI=mongodb://localhost:27017/express_crud_db

4. Connecting MongoDB to Express.js

4.1 Install MongoDB Dependencies

npm install mongoose

4.2 Create Database Configuration File

File: src/config/database.ts

import mongoose from 'mongoose';

const connectMongoDB = async () => {
  try {
    await mongoose.connect(process.env.MONGODB_URI || '');
    console.log('MongoDB Connected');
  } catch (error) {
    console.error('MongoDB connection failed:', error);
    process.exit(1);
  }
};

export default connectMongoDB;

4.3 Update `app.ts`

import connectMongoDB from './config/database';
connectMongoDB();

4.4 Create a User Model

File: src/models/userModel.ts

import mongoose, { Schema, Document } from 'mongoose';

interface IUser extends Document {
  name: string;
  email: string;
}

const UserSchema: Schema = new Schema({
  name: { type: String, required: true },
  email: { type: String, required: true }
});

export default mongoose.model<IUser>('User', UserSchema);

5. Setting Up PostgreSQL

5.1 Install PostgreSQL Locally

Download PostgreSQL from the official website.
Install pgAdmin (GUI tool for PostgreSQL).

5.2 Create a Database

Open psql or pgAdmin.
Run:

CREATE DATABASE express_crud_db;

5.3 Set Up PostgreSQL Connection URL

POSTGRESQL_URI=postgresql://user:password@localhost:5432/express_crud_db

6. Connecting PostgreSQL to Express.js

6.1 Install PostgreSQL Dependencies

npm install knex pg

6.2 Configure Knex.js

File: src/config/knex.ts

import knex from 'knex';

const db = knex({
  client: 'pg',
  connection: process.env.POSTGRESQL_URI,
  pool: { min: 0, max: 7 }
});

export default db;

6.3 Create a Migration File

npx knex migrate:make create_users_table --knexfile src/config/knex.ts

File: src/migrations/<timestamp>_create_users_table.ts

export function up(knex) {
  return knex.schema.createTable('users', (table) => {
    table.increments('id').primary();
    table.string('name').notNullable();
    table.string('email').notNullable().unique();
  });
}

export function down(knex) {
  return knex.schema.dropTable('users');
}

Run the migration:

npx knex migrate:latest --knexfile src/config/knex.ts

6.4 Create a User Model

File: src/models/userModel.ts

import db from '../config/knex';

export const getAllUsers = () => db('users').select('*');
export const getUserById = (id: number) => db('users').where({ id }).first();
export const createUser = (user: { name: string; email: string }) => db('users').insert(user);
export const updateUser = (id: number, user: { name?: string; email?: string }) => db('users').where({ id }).update(user);
export const deleteUser = (id: number) => db('users').where({ id }).del();

7. Implementing CRUD Operations with Database

7.1 Update Controller for MongoDB

File: src/controllers/userController.ts

import User from '../models/userModel';

export const getUsers = async (req, res) => {
  const users = await User.find();
  res.json(users);
};

7.2 Update Controller for PostgreSQL

import { getAllUsers, getUserById, createUser, updateUser, deleteUser } from '../models/userModel';

export const getUsers = async (req, res) => {
  const users = await getAllUsers();
  res.json(users);
};

8. Environment Variables for Database Configuration

File: .env

MONGODB_URI=mongodb://localhost:27017/express_crud_db
POSTGRESQL_URI=postgresql://user:password@localhost:5432/express_crud_db

Update your app.ts to load .env:

import dotenv from 'dotenv';
dotenv.config();

9. Best Practices

Use environment variables for sensitive data.
Validate data before saving to the database.
Use connection pools for PostgreSQL.
Properly handle database connection errors.
Avoid exposing raw database errors to the client.

10. Conclusion

MongoDB: Great for dynamic, schema-less applications.
PostgreSQL: Best for structured, relational data with strict validation.

Choose the database based on your project requirements.

✨ Your Express.js app is now connected to both MongoDB and PostgreSQL! 🚀

Author: Mohin Sheikh

Follow me on GitHub for more insights!

Building an Express.js CRUD Application from Scratch: A Step-by-Step Guide for Beginners

Mohin Sheikh — Wed, 25 Dec 2024 07:59:20 +0000

📖 Table of Contents

Introduction to Express.js
Setting Up the Project Environment
Project Structure Overview
Installing Dependencies
Creating the Express Server
Defining Routes
Creating Controllers
Setting Up a Database (Optional)
Implementing CRUD Operations
- Create (POST)
- Read (GET)
- Update (PUT)
- Delete (DELETE)
Middleware and Error Handling
Testing the APIs with Postman
Conclusion and Best Practices

1. Introduction to Express.js

What is Express.js?

Express.js is a minimal and flexible Node.js web application framework that provides a robust set of features for building web and mobile applications.
Why Use Express.js?
- Lightweight and fast.
- Flexible routing system.
- Middleware support.
- Easy integration with databases.

2. Setting Up the Project Environment

Install Node.js (LTS version recommended).
Verify installation:

  node -v
  npm -v

Initialize a new Node.js project:

  mkdir express-crud-app
  cd express-crud-app
  npm init -y

3. Project Structure Overview

Organize your project like this:

express-crud-app/
│
├── src/
│   ├── controllers/
│   │   ├── userController.ts
│   │
│   ├── routes/
│   │   ├── userRoutes.ts
│   │
│   ├── models/
│   │   ├── userModel.ts
│   │
│   ├── middlewares/
│   │   ├── errorHandler.ts
│   │
│   ├── app.ts
│
├── package.json
├── tsconfig.json
└── README.md

4. Installing Dependencies

Install necessary dependencies:

npm install express body-parser mongoose
npm install --save-dev typescript @types/express @types/node nodemon

Update package.json scripts:

"scripts": {
  "start": "node dist/app.js",
  "dev": "nodemon src/app.ts"
}

5. Creating the Express Server

File: src/app.ts

import express, { Request, Response } from 'express';
import userRoutes from './routes/userRoutes';

const app = express();
const PORT = 3000;

app.use(express.json());

// Routes
app.use('/api/users', userRoutes);

// Health Check
app.get('/', (req: Request, res: Response) => {
  res.send('Express Server is running!');
});

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

6. Defining Routes

File: src/routes/userRoutes.ts

import { Router } from 'express';
import {
  getUsers,
  getUserById,
  createUser,
  updateUser,
  deleteUser
} from '../controllers/userController';

const router = Router();

router.get('/', getUsers);
router.get('/:id', getUserById);
router.post('/', createUser);
router.put('/:id', updateUser);
router.delete('/:id', deleteUser);

export default router;

7. Creating Controllers

File: src/controllers/userController.ts

import { Request, Response } from 'express';

let users = [
  { id: 1, name: 'John Doe', email: 'john@example.com' },
];

export const getUsers = (req: Request, res: Response) => {
  res.status(200).json(users);
};

export const getUserById = (req: Request, res: Response) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (user) {
    res.status(200).json(user);
  } else {
    res.status(404).json({ message: 'User not found' });
  }
};

export const createUser = (req: Request, res: Response) => {
  const newUser = { id: users.length + 1, ...req.body };
  users.push(newUser);
  res.status(201).json(newUser);
};

export const updateUser = (req: Request, res: Response) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (user) {
    Object.assign(user, req.body);
    res.status(200).json(user);
  } else {
    res.status(404).json({ message: 'User not found' });
  }
};

export const deleteUser = (req: Request, res: Response) => {
  users = users.filter(u => u.id !== parseInt(req.params.id));
  res.status(200).json({ message: 'User deleted' });
};

8. Middleware and Error Handling

File: src/middlewares/errorHandler.ts

import { Request, Response, NextFunction } from 'express';

export const errorHandler = (err: Error, req: Request, res: Response, next: NextFunction) => {
  console.error(err.stack);
  res.status(500).json({ message: 'Something went wrong!' });
};

Add it to app.ts:

import { errorHandler } from './middlewares/errorHandler';
app.use(errorHandler);

9. Testing with Postman

Sample Requests and Responses

1. Create User (POST /api/users)

Request Body:

{
  "name": "Alice",
  "email": "alice@example.com"
}

Response:

{
  "id": 2,
  "name": "Alice",
  "email": "alice@example.com"
}

2. Get All Users (GET /api/users)

Response:

[
  {
    "id": 1,
    "name": "John Doe",
    "email": "john@example.com"
  },
  {
    "id": 2,
    "name": "Alice",
    "email": "alice@example.com"
  }
]

3. Update User (PUT /api/users/:id)

Request Body:

{
  "name": "Updated Name"
}

Response:

{
  "id": 1,
  "name": "Updated Name",
  "email": "john@example.com"
}

4. Delete User (DELETE /api/users/:id)

Response:

{
  "message": "User deleted"
}

10. Conclusion and Best Practices

Always validate user input.
Use middleware effectively.
Follow RESTful API conventions.
Organize code into meaningful files and folders.

11. Next Steps

✨ Congratulations! You've built an Express.js CRUD application from scratch.

Author: Mohin Sheikh

Follow me on GitHub for more insights!