Forem: keshav Sandhu

🚀 JavaScript Async/Await vs `.then()` : The Microtask & Event Loop Secret

keshav Sandhu — Wed, 18 Mar 2026 17:09:24 +0000

Ever seen this and wondered why the output changes just by reordering lines?

async function hi() {
  return "there";
}

// Version A
const waitedhi = await hi();
console.log(waitedhi);

hi().then(res => console.log(res));

console.log("end");

// Version B
hi().then(res => console.log(res));

const waitedhi = await hi();
console.log(waitedhi);

console.log("end");

👀 Same code… different output. Why?

🧠 The Hidden Mechanism: Microtasks

Both await and .then() use Promises, and both schedule work in the microtask queue.

👉 Key rule:

Microtasks run in the order they are added (FIFO)

⚡ What `await` really does

await hi();

is roughly:

hi().then(result => {
  // rest of your code
});

So:

.then() → schedules a microtask
await → schedules a microtask (continuation)

🔥 Why order matters

Version A

await schedules continuation
resumes → logs "there"
.then() schedules another microtask
"end" logs
.then() runs

✅ Output:

there
end
there

Version B

.then() → microtask A
await → microtask B
Run A → Run B

✅ Output:

there
there
end

🧩 The Bigger Picture: Event Loop

To fully understand this, you need 3 things:

1️⃣ Call Stack

Executes synchronous code
Runs line by line
Example:

console.log("start");

2️⃣ Microtask Queue (High Priority)

Promises (.then, await)
Runs immediately after stack is empty

3️⃣ Macrotask Queue (Low Priority)

setTimeout
setInterval
Runs after all microtasks are done

⚡ Golden Rule

JS finishes the call stack → runs ALL microtasks → then runs ONE macrotask

🧪 Full Example

console.log("start");

setTimeout(() => console.log("timeout"), 0);

Promise.resolve().then(() => console.log("then"));

await Promise.resolve();

console.log("end");

🔍 Execution Flow

Step 1: Call Stack

start

Step 2: Queues

Microtasks: [then, await-resume]
Macrotasks: [timeout]

Step 3: Run Microtasks

then
end

Step 4: Run Macrotask

timeout

✅ Final Output

start
then
end
timeout

🎯 Final Takeaways

await = pause + schedule continuation as microtask
.then() = directly schedules microtask
Microtasks always run before macrotasks
Order of scheduling = order of execution

💬 Once you understand this, async JavaScript stops feeling random and starts feeling predictable.

MongoDB vs PostgreSQL: When to Choose Which One? (With Real-World Examples)

keshav Sandhu — Thu, 22 Jan 2026 16:59:15 +0000

Choosing the right database is one of the most important architectural decisions you'll make in a project. Pick the wrong one, and you’ll fight with schema migrations, performance bottlenecks, or scalability issues down the road. Pick the right one, and your development speed, data consistency, and long-term maintenance will thank you.

Two of the most popular options today are MongoDB (NoSQL, document-oriented) and PostgreSQL (relational, SQL). They solve different problems well, and the “best” choice almost always depends on your data model, query patterns, and scalability needs.

In this post, we’ll break down:

Core strengths and trade-offs of each
Clear guidelines on when to choose one over the other
Real-world projects that use each (including an admin-panel example)
A side-by-side comparison to help you decide quickly

Let’s dive in.

1. MongoDB: Flexible, Schema-less, Horizontally Scalable

What MongoDB Is Great For

MongoDB stores data as JSON-like BSON documents in collections. There’s no fixed schema - you can add new fields anytime without migrations.

Key strengths:

Rapid development when requirements evolve quickly
Handling unstructured or semi-structured data (e.g., user profiles with optional fields, logs, IoT sensor data)
High write throughput and horizontal scaling via sharding
Nested data models that reduce the need for JOINs
Built-in replication and auto-sharding for distributed systems

Trade-offs:

Weaker ACID guarantees by default (though multi-document transactions exist, they’re slower)
Complex queries with many joins are harder and less efficient
Eventual consistency in distributed setups can bite you if you need strict consistency

When to Choose MongoDB

Choose MongoDB when:

Your data structure changes frequently
You have high-velocity writes (real-time analytics, event streaming)
You need to scale horizontally across many servers easily
You’re working with hierarchical or variable data (e.g., product catalogs with different attributes per category)

Real-World MongoDB Projects

Aadhaar (India’s National ID System)

The world’s largest biometric database, storing records for over 1.3 billion people. MongoDB handles massive volumes of semi-structured biometric and demographic data. Its flexible schema allows quick updates as new data types (fingerprints, iris scans) are added, and sharding supports enormous scale across distributed enrollment centers.
Wells Fargo Payment Processing

Processes millions of card transactions daily. MongoDB’s document model easily accommodates varying transaction metadata, and its horizontal scaling ensures low-latency fraud detection and real-time settlement.
Novo Nordisk Clinical Trials Platform

Uses MongoDB Atlas to store and analyze unstructured clinical study data. Researchers can evolve data models as trials progress, and generative AI tools query the flexible documents to produce reports in minutes.

2. PostgreSQL: Powerful, Relational, ACID-Compliant

What PostgreSQL Is Great For

PostgreSQL is a battle-tested relational database with full SQL support, rich data types, and extensions.

Key strengths:

Strong ACID compliance and transactional integrity
Complex queries with JOINs, aggregations, window functions
Advanced features: JSONB (best-of-both-worlds semi-structured data), full-text search, PostGIS for geospatial, custom extensions
Data consistency with constraints, foreign keys, triggers
Excellent for analytical workloads and reporting

Trade-offs:

Schema changes require migrations (can slow iteration in early stages)
Vertical scaling is primary; horizontal scaling requires extra tools (Citus, sharding)
Higher overhead for very high-write, unstructured workloads

When to Choose PostgreSQL

Choose PostgreSQL when:

You have structured data with clear relationships
You need complex queries, reporting, or analytics
Data integrity and consistency are non-negotiable (finance, inventory, user management)
You want to mix relational and semi-structured data (thanks to JSONB)

Real-World PostgreSQL Projects

Reddit’s Core Data and Analytics

Reddit uses PostgreSQL for storing posts, comments, votes, users, and subreddits. The relational model handles complex relationships (e.g., comment threads, moderation actions) and ensures transactional consistency during high-traffic voting spikes.
NASA International Space Station Monitoring

Telemetry and event data from the ISS are stored in PostgreSQL for ground replication. ACID guarantees prevent data loss, and reliable replication supports mission-critical real-time monitoring.
Library Management System Admin Panel (Common Full-Stack Example)

Many real-world admin dashboards (library systems, school management, e-commerce backends) use PostgreSQL.
- Tables: users, books, authors, borrow_records, fines
- Relationships: A book has one author (foreign key), a user can have many borrow records
- Typical admin-panel features:
  - Search/overdue reports using JOINs and aggregations
  - Atomic borrow/return transactions (update inventory and create record in one transaction)
  - Role-based access with consistent user data PostgreSQL shines here because the data is highly relational, queries are complex (e.g., “top 10 most borrowed books this month”), and consistency matters (you can’t have a borrow record without updating book availability).

Side-by-Side Comparison

Aspect	MongoDB	PostgreSQL
Data Model	Document (flexible schema)	Relational (fixed schema)
Query Language	MongoDB Query Language / Aggregation	SQL (rich, standardized)
Scaling	Horizontal (sharding built-in)	Primarily vertical; horizontal via extensions
Transactions	Multi-document (slower)	Full ACID, multi-statement
Complex Joins	Difficult/inefficient	Excellent
Schema Evolution	Easy (schema-less)	Requires migrations
Best Workloads	High-write, evolving data	Analytics, relationships, consistency
JSON/Semi-structured	Native	Excellent via JSONB

Key Takeaways & Decision Checklist

Start with data structure
- Highly relational with fixed fields → PostgreSQL
- Variable/nested/unpredictable fields → MongoDB
Think about queries
- Lots of JOINs, aggregations, reporting → PostgreSQL
- Mostly simple lookups or document retrieval → MongoDB
Consider consistency needs
- Banking, inventory, admin actions → PostgreSQL
- Logs, events, user-generated content → MongoDB
Future scaling
- Predict massive horizontal growth early → MongoDB
- Start simple and scale vertically first → PostgreSQL
You don’t always have to choose one

Many modern apps use polyglot persistence: PostgreSQL for core transactional data and MongoDB for logs, analytics, or flexible user content.

The right database isn’t about which is “better” - it’s about which fits your problem today and tomorrow.

What’s your go-to database and why? Drop your experiences (or war stories) in the comments! 🚀

Dockerizing Node.js Microservices with Docker Compose

keshav Sandhu — Wed, 14 Jan 2026 16:57:43 +0000

If you’re working with Node.js microservices and still running everything manually on your machine - this post is for you.

In this guide, we’ll Dockerize multiple backend microservices and run them together using Docker Compose, the same way it’s done in real-world projects.

No frontend. No fluff. Just clean backend architecture.

Why Docker for Microservices?

Microservices mean:

Multiple Node.js apps
Different ports
Shared infrastructure (DB, cache, queues)

Without Docker:

“Works on my machine” issues
Manual setup every time
Painful onboarding

With Docker:

Same environment everywhere
One command to start everything
Easy scaling & CI/CD

What We’ll Build

Backend-only setup with:

auth-service
user-service
order-service
MongoDB
Docker + Docker Compose

Each service:

Runs in its own container
Has its own Dockerfile
Communicates over Docker network

Folder Structure

backend/
│
├── auth-service/
│   ├── Dockerfile
│   ├── package.json
│   ├── server.js
│   └── .dockerignore
│
├── user-service/
│   ├── Dockerfile
│   ├── package.json
│   ├── server.js
│   └── .dockerignore
│
├── order-service/
│   ├── Dockerfile
│   ├── package.json
│   ├── server.js
│   └── .dockerignore
│
├── docker-compose.yml
└── .env

Common Dockerfile (Node.js Service)

Each service uses the same Dockerfile pattern.

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm install --production

COPY . .

EXPOSE 5000

CMD ["npm", "start"]

`.dockerignore`

node_modules
.env
npm-debug.log

This keeps images small and clean.

Sample Service Code

Example: auth-service/server.js

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

app.get("/health", (req, res) => {
  res.json({ service: "auth", status: "ok" });
});

app.listen(5000, () => {
  console.log("Auth service running on port 5000");
});

Each microservice exposes a /health endpoint — a best practice for containers.

Docker Compose (Multiple Microservices)

This is where the magic happens.

version: "3.9"

services:
  auth-service:
    build: ./auth-service
    ports:
      - "5001:5000"
    env_file:
      - .env
    depends_on:
      - mongo

  user-service:
    build: ./user-service
    ports:
      - "5002:5000"
    env_file:
      - .env
    depends_on:
      - mongo

  order-service:
    build: ./order-service
    ports:
      - "5003:5000"
    env_file:
      - .env
    depends_on:
      - mongo

  mongo:
    image: mongo:6
    ports:
      - "27017:27017"
    volumes:
      - mongo_data:/data/db

volumes:
  mongo_data:

Environment Variables

.env

MONGO_URI=mongodb://mongo:27017/microservices_db
JWT_SECRET=supersecret

📌 Important Docker Rule
Inside Docker:

❌ localhost does NOT work
✅ Use service names (mongo, user-service, etc.)

Inter-Service Communication

Inside containers:

auth-service → http://user-service:5000
user-service → http://order-service:5000

Example:

axios.get("http://user-service:5000/health");

Docker automatically creates a shared network for services in docker-compose.yml.

Run Everything

docker-compose up --build

Test locally:

Production-Ready Tips

✔ Give each service its own database
✔ Don’t expose ports for internal services
✔ Add health checks
✔ Use an API Gateway (NGINX / Kong)
✔ Move to Kubernetes when scaling

Key Takeaway

Each microservice runs in its own Docker container, communicates via Docker’s internal network using service names, and is orchestrated with Docker Compose.

If you understand this setup, you’re already ahead of many backend devs.

If you found this useful, drop a ❤️ or comment - happy to write a follow-up!

MongoDB aggregation Pipelines simplified

keshav Sandhu — Mon, 27 Oct 2025 16:48:40 +0000

MongoDB Aggregation Pipeline stages

MongoDB’s aggregation pipeline is a powerful framework for transforming, filtering, and analyzing data in collections similar to SQL’s GROUP BY, JOIN, WHERE, etc.

🧱 Basic Structure

An aggregation pipeline is an array of stages, each stage transforms the documents and passes them to the next stage.

db.collection.aggregate([
  { <stage1> },
  { <stage2> },
  ...
])

1️⃣ `$match` - Filtering Documents

Works like the find() query. Filters documents based on conditions.

Example:

db.orders.aggregate([
  { $match: { status: "delivered" } }
])

✅ Returns only documents where status = "delivered".

2️⃣ `$project` - Select or Reshape Fields

Used to include/exclude fields or create computed fields.

Example:

db.orders.aggregate([
  { 
    $project: { 
      _id: 0,
      item: 1,
      total: { $multiply: ["$price", "$quantity"] }
    }
  }
])

✅ Outputs only item and a computed field total.

3️⃣ `$group` - Group Documents & Aggregate Data

Groups documents by a key and applies aggregation operators (like $sum, $avg, etc.).

Example:

db.orders.aggregate([
  {
    $group: {
      _id: "$customerId",
      totalSpent: { $sum: { $multiply: ["$price", "$quantity"] } },
      numOrders: { $sum: 1 }
    }
  }
])

✅ Groups by customer and calculates:

Total spent
Number of orders

4️⃣ `$sort` - Sort Results

Sorts documents by one or more fields.

Example:

db.orders.aggregate([
  { $sort: { total: -1 } }  // descending
])

✅ Sorts by total in descending order.

5️⃣ `$limit` and `$skip` - Pagination

$limit: Restricts the number of documents.
$skip: Skips a number of documents.

Example:

db.orders.aggregate([
  { $sort: { date: -1 } },
  { $skip: 10 },
  { $limit: 5 }
])

✅ Skips first 10, returns next 5 (useful for pagination).

6️⃣ `$unwind` - Deconstruct Arrays

Splits array fields into multiple documents (one per element).

Example:

db.orders.aggregate([
  { $unwind: "$items" }
])

✅ If a document has an array items: [a, b, c], it becomes 3 documents - one for each item.

7️⃣ `$lookup` - Join with Another Collection

Performs a left outer join between two collections.

Example:

db.orders.aggregate([
  {
    $lookup: {
      from: "customers",
      localField: "customerId",
      foreignField: "_id",
      as: "customer"
    }
  }
])

✅ Adds matching customer info to each order under the field customer.

8️⃣ `$addFields` - Add or Modify Fields

Adds new fields or modifies existing ones.

Example:

db.orders.aggregate([
  {
    $addFields: {
      total: { $multiply: ["$price", "$quantity"] },
      statusUpper: { $toUpper: "$status" }
    }
  }
])

✅ Adds computed total and uppercase status.

9️⃣ `$count` - Count Documents

Counts the number of documents in the pipeline.

Example:

db.orders.aggregate([
  { $match: { status: "pending" } },
  { $count: "pendingOrders" }
])

✅ Returns { pendingOrders: 12 }.

🔟 `$facet` - Multiple Pipelines in One

Allows parallel aggregations on the same dataset.

Example:

db.orders.aggregate([
  {
    $facet: {
      totalByCustomer: [
        { $group: { _id: "$customerId", total: { $sum: "$amount" } } }
      ],
      avgOrderValue: [
        { $group: { _id: null, avg: { $avg: "$amount" } } }
      ]
    }
  }
])

✅ Runs two aggregations in one pipeline.

1️⃣1️⃣ `$bucket` - Categorize Into Ranges

Groups values into defined ranges (buckets).

Example:

db.sales.aggregate([
  {
    $bucket: {
      groupBy: "$amount",
      boundaries: [0, 100, 500, 1000],
      default: "Other",
      output: { count: { $sum: 1 } }
    }
  }
])

✅ Categorizes sales by amount ranges.

1️⃣2️⃣ `$out` - Write Results to a Collection

Saves aggregation results into a new collection.

Example:

db.orders.aggregate([
  { $match: { status: "completed" } },
  { $out: "completedOrders" }
])

✅ Writes output into a new collection completedOrders.

1️⃣3️⃣ `$merge` - Merge Results into an Existing Collection

Similar to $out, but can update or insert documents.

Example:

db.orders.aggregate([
  { $group: { _id: "$customerId", total: { $sum: "$amount" } } },
  { $merge: { into: "customerTotals", whenMatched: "merge", whenNotMatched: "insert" } }
])

✅ Updates or inserts aggregated data into customerTotals.

Let me know if this helped you in some way.

Converting any JS project to TS backend

keshav Sandhu — Thu, 16 Oct 2025 12:55:04 +0000

First step if you are setting up from scratch

✅ 1. Initialize Your Node.js Project

bash
npm init -y

Creates a package.json file.

Conversion start now

✅ 2. Install TypeScript and Types for Node

bash
npm install --save-dev typescript @types/node

typescript: the TypeScript compiler
@types/node: type definitions for Node.js (so fs, path, etc. work)

✅ 3. Initialize TypeScript Config

bash
npx tsc --init

This generates a tsconfig.json. You can use the default, but you might want to tweak a few settings.

Recommended tsconfig.json tweaks:

jsonc
{
"compilerOptions": {
"target": "es2020",
"module": "commonjs",
"outDir": "./dist",
"rootDir": "./src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true
},
"include": ["src"]
}

✅ 4. Create Your Project Structure

bash
mkdir src
touch src/index.ts

Add a simple example in src/index.ts:

ts
const greet = (name: string) => {
console.log(Hello, ${name}!);
};

greet("TypeScript");

✅ 5. Compile TypeScript

bash
npx tsc

This compiles your TypeScript to JavaScript in the dist folder.

✅ 6. Run the Compiled JavaScript

bash
node dist/index.js

🔁 Optional: Add NPM Scripts

Edit package.json to make your workflow easier:

json
"scripts": {
"build": "tsc",
"start": "node dist/index.js",
"dev": "tsc --watch"
}

Now you can run:

bash
npm run build # Compile
npm start # Run
npm run dev # Watch and recompile on changes

🧪 Optional: Use ts-node to Run TS Directly (without compiling)

Install it:

bash
npm install --save-dev ts-node

Run TypeScript directly:

bash
npx ts-node src/index.ts

JavaScript Object References – Explained with Examples

keshav Sandhu — Tue, 07 Oct 2025 17:09:56 +0000

Lets start

🔹 1. Objects Are Passed by Reference

In JavaScript, objects (including arrays and functions) are assigned and passed by reference, not by value.

js
const a = { name: "Alice" };
const b = a;

b.name = "Bob";

console.log(a.name); // ➜ "Bob"

✅ a and b both point to the same object in memory.

🔹 2. Primitive Values Are Passed by Value

js
let x = 10;
let y = x;

y++;

console.log(x); // 10
console.log(y); // 11

✅ x and y are completely separate.

🔹 3. Object Comparison Checks Reference, Not Structure

js
const obj1 = { a: 1 };
const obj2 = { a: 1 };

console.log(obj1 === obj2); // false

Even though they look identical, they're two different objects in memory.

✅ To compare deeply:

js
JSON.stringify(obj1) === JSON.stringify(obj2); // true

Or use a deep equality library like lodash.isEqual.

🔹 4. Mutating vs Copying Objects

❌ Mutating Original:

js
const user = { name: "Alice" };
function update(user) {
user.name = "Bob";
}
update(user);
console.log(user.name); // Bob

✅ Copying (Shallow):

js
const original = { a: 1 };
const copy = { ...original };

copy.a = 2;

console.log(original.a); // 1

... or Object.assign() creates a shallow copy - only top-level is copied.

🔹 5. Shallow vs Deep Copy

js
const obj = { a: 1, b: { c: 2 } };

const shallowCopy = { ...obj };
shallowCopy.b.c = 99;

console.log(obj.b.c); // 99 ❌ (still affected!)

✅ Deep Copy (one way):

js
const deepCopy = JSON.parse(JSON.stringify(obj));

This has limitations (won’t work with functions, Dates, undefined, circular refs).

🔹 6. Object Mutation in Arrays

js
const users = [{ name: "Alice" }];
const newUsers = users;

newUsers[0].name = "Bob";

console.log(users[0].name); // "Bob" ❗

users and newUsers point to the same array and same object inside it.

🔹 7. Object Identity in State (React relevance)

In React:

js
const [state, setState] = useState({ count: 0 });

setState({ count: 0 }); // Will re-render (new object reference)

React compares by reference, not deep equality.

Even if content is same, new object → re-render ✅
But if reference is same, no re-render (optimization)

🔹 8. Freezing an Object (Make it Immutable)

js
const obj = Object.freeze({ a: 1 });
obj.a = 99; // ❌ won't change

console.log(obj.a); // 1

Works only on top-level (not deeply)
Good for read-only configs

🔹 9. References Inside Functions

js
function mutate(obj) {
obj.changed = true;
}
const data = {};
mutate(data);

console.log(data.changed); // true

✅ Passing an object to a function allows mutating it from inside.

🔹 10. Comparing Arrays and Functions by Reference

js
const a = [1, 2];
const b = [1, 2];
console.log(a === b); // false

const f1 = () => {};
const f2 = () => {};
console.log(f1 === f2); // false

Even if they look identical, they are different objects/functions in memory.

🧠 Summary – Key Concepts

Concept	Reference Behavior
Objects	Reference
Arrays	Reference
Functions	Reference
Primitives (string, number)	Value
Comparison (===)	Compares references
Spread/assign	Shallow copy
JSON methods	Deep copy (with limits)

open source

keshav Sandhu — Thu, 28 Aug 2025 17:07:58 +0000

🌍 How to Contribute to Open Source (Even If You're Just Starting Out)

keshav Sandhu ・ Aug 28

#opensource #ai #agentaichallenge #programming

🌍 How to Contribute to Open Source (Even If You're Just Starting Out)

keshav Sandhu — Thu, 28 Aug 2025 17:07:28 +0000

Contributing to open source can feel intimidating like you're walking into someone else’s codebase without an invitation. But the truth is: open source is one of the best ways to level up your skills, build your **developer reputation, and give back to the community.

Whether you're a beginner, student, or seasoned dev, this post breaks down exactly how to get started contributing to open source.

💡 Why Contribute to Open Source?

Here’s what you gain:

✅ Real-world experience
✅ Learn by reading (and writing) production-quality code
✅ Improve collaboration, Git, and code review skills
✅ Get visibility and build a strong portfolio
✅ Make a real impact, your code could be used by thousands (or millions!)

🪜 Step-by-Step: How to Contribute to an Open Source Project

1. Set Expectations (Start Small)

You don’t have to dive into the Linux kernel or rewrite a compiler. Start with small, meaningful contributions like:

Fixing typos or broken links in documentation
Improving README files
Filing or triaging issues
Fixing bugs labeled "good first issue"
Writing tests or improving coverage

2. Find a Project That Interests You

You’ll stay more motivated if the project relates to something you use or care about.

🧭 Where to find beginner-friendly projects:

Good First Issue
Up For Grabs
CodeTriage
GitHub search with label:"good first issue" or label:"help wanted"

Also check:

Tools or libraries you already use (VS Code, React, Django, etc.)
Awesome lists on GitHub like Awesome for Beginners

3. Understand the Project

Before writing a single line of code:

✅ Read the README
✅ Check the CONTRIBUTING.md file (rules + how-tos)
✅ Browse open issues and discussions
✅ Look at the project’s code structure and commit history
✅ Join the project's Discord, Slack, or Gitter, if available

Pro tip: Some projects even have a DEVELOPERS.md or docs/ folder to explain how things work.

4. Pick a First Issue (and Ask to Work on It)

Find an issue labeled:

good first issue
help wanted
beginner friendly

Comment on it:

Hi! I'd love to work on this issue. Is it still available?

Wait for a maintainer to assign it to you or confirm it's open. Then you're good to go!

5. Fork → Clone → Code

Standard contribution flow:

Fork the repo to your GitHub account
Clone it to your local machine

git clone https://github.com/your-username/project-name

Create a feature branch

bash
git checkout -b fix-typo-in-readme

Make your changes and commit
Push your branch and open a Pull Request (PR)

6. Write a Great Pull Request (PR)

Your PR should:

Have a clear title (Fix typo in README)
Include a brief description of the change
Reference the issue number (e.g., Closes #42)
Pass tests and linters (run them locally if possible)

Example PR description:

Summary

Fixed a small typo in the README file under the installation section.

Closes #42

7. Be Open to Feedback

Most maintainers are kind but they may request changes. That’s totally normal.

✅ Respond politely
✅ Ask questions if you’re unsure
✅ Make revisions and push again

Once approved, your code will be merged 🎉

🙌 Best Practices and Pro Tips

Stay consistent with the project's coding style
Always pull the latest main branch before starting new work
Write clear commit messages (fix: correct typo in command)
Don’t take feedback personally, it’s part of learning
Celebrate small wins!

💬 Final Thoughts

Open source isn’t about being perfect. It’s about collaborating and growing together.

Start small. Contribute often. And remember: the first PR is the hardest after that, it gets easier (and addictive 😄).

✅ Resources to Help You Get Started

First Contributions – Practice open source contribution in a safe repo
GitHub Docs – Forking Projects
Git Handbook by GitHub

👋 Have you contributed to open source before? Got tips or favorite beginner-friendly projects? Drop them in the comments and let’s help more devs get started.

🔥 Demystifying Scalability in Backend Systems (with Microservices in Mind)

keshav Sandhu — Sun, 24 Aug 2025 16:33:17 +0000

In the world of backend architecture, one term you'll hear over and over again is scalability. It’s not just a buzzword—it's the backbone of building software that survives real-world usage and growth.

But what is scalability? And how do microservices help us scale smarter, not harder?

Let’s break it down.

🚀 What Is Scalability?

At its core, scalability is a system’s ability to handle increased load gracefully whether that load comes from more users, more data, or higher transaction rates.

A scalable backend can:

Grow to meet demand without crashing or slowing down
Shrink when demand drops to save costs
Be updated and deployed without major downtime

⚙️ Two Types of Scalability

1. Vertical Scaling (Scaling Up)

Upgrade your existing server by adding more CPU, RAM, or storage.

✅ Simple to implement
❌ Eventually hits hardware limits
❌ More expensive per unit as you scale

2. Horizontal Scaling (Scaling Out)

Add more machines (servers or containers) to distribute the load.

✅ Highly scalable
✅ Cost-effective at scale
✅ Enables fault tolerance
❌ Requires smarter architecture

💡 Why Microservices Make Scaling Easier

Monolithic apps bundle all features in one codebase. If one feature (e.g., checkout) needs more resources, you have to scale the whole app—wasting compute and memory.

With microservices, you can isolate and scale only the parts that are under pressure.

🛒 Example: E-commerce Platform on Sale Day

Microservice	Load Spike	Scaling Strategy
🧑‍💼 User Service	Low	No scaling needed
🛍️ Product Service	High	Add 5 more instances via container orchestration
💳 Payment Service	Very High	Scale + add a queue (e.g., Kafka) to absorb spikes
📦 Shipping Service	Moderate	Scale 2x horizontally

With microservices, each component runs independently. You can deploy, scale, and monitor each service on its own.

🛠️ Tools That Make It Happen

Here’s how teams scale microservices efficiently:

Containers: Docker lets you package services with everything they need to run
Orchestration: Kubernetes or ECS handles service scaling, networking, and availability
Load Balancers: NGINX, HAProxy, or cloud-based balancers spread traffic across instances
Queues: Kafka, RabbitMQ, and AWS SQS prevent bottlenecks and enable async processing
CDNs + Caching: Redis, Memcached, or Cloudflare reduce pressure on services

📈 Scalability in Practice

Scalability isn’t just about handling a one-time surge, it's about being ready for growth, volatility, and resilience.

It lets your system:

Handle millions of users without rewriting everything
Deploy updates with zero downtime
Optimize infrastructure cost over time

🧠 TL;DR

Scalability = your system’s ability to grow with demand
Vertical Scaling = more power to one server
Horizontal Scaling = more servers sharing the load
Microservices enable targeted, cost-effective scaling
Tools like Docker, Kubernetes, Kafka, and Redis are your best friends here

💬 Over to you!
What challenges have you faced while scaling backend systems? Are you using microservices or still on a monolith? Let’s share lessons in the comments.

Learn polyfill in Javascript

keshav Sandhu — Mon, 28 Jul 2025 16:21:40 +0000

Creating a polyfill involves writing code (usually JavaScript) that emulates a newer feature in older browsers or environments that don't support that feature natively.

✅ What is a Polyfill?

A polyfill is a piece of code (usually JavaScript) that implements a modern web API or feature on browsers that do not support it.

🧱 Steps to Create a Polyfill

Let’s walk through how to create one:

1. Choose the Feature to Polyfill

Pick a feature that isn't available in all target environments. Example: Array.prototype.includes

2. Check if the Feature Exists

Use a feature detection check so the polyfill only runs when needed.

js
if (!Array.prototype.includes) {
// Provide your own implementation
}

3. Implement the Feature

Write the functionality in a way that mimics the native behavior as closely as possible.

✅ Example: Polyfill for Array.prototype.includes

js
if (!Array.prototype.includes) {
Array.prototype.includes = function(searchElement, fromIndex) {
if (this == null) {
throw new TypeError('"this" is null or not defined');
}

const o = Object(this);
const len = o.length >>> 0;

if (len === 0) return false;

const n = fromIndex | 0;
let k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);

while (k < len) {
  if (o[k] === searchElement || (typeof o[k] === 'number' && typeof searchElement === 'number' && isNaN(o[k]) && isNaN(searchElement))) {
    return true;
  }
  k++;
}

return false;

};
}

4. Test the Polyfill

Use browsers that don’t support the feature and verify that your polyfill works correctly. You can use:

Old browsers (via virtual machines or BrowserStack)
JavaScript engines in environments like Node.js

5. Distribute or Package

You can include your polyfill directly in your codebase.
Or, publish it as an npm package for reuse.

📦 Tip: Use Existing Polyfills

Before writing your own, check:

MDN Polyfill Examples
polyfill.io
Libraries like core-js, es-shims

Resume-worthy project ideas for Frontend Devs

keshav Sandhu — Thu, 12 Jun 2025 16:55:43 +0000

1. 🧠 Mind Mirror – AI-powered Mood & Thought Tracker

Concept: A daily journaling app where users type what they're feeling, and the app uses sentiment analysis + AI-generated visual metaphors to reflect back their mood.
Tech: React, Next.js API routes, OpenAI API, localStorage or Supabase for persistence.
Why it's cool: Merges mental health awareness with generative art and AI.

2. 🪞 EchoRoom – Conversational Rehearsal Tool

Concept: A virtual space where users can rehearse conversations (job interviews, tough talks, etc.) with an AI character trained to simulate different responses.
Tech: Next.js, WebRTC or simple audio API, OpenAI for convo logic.
Why it's useful: Targets real user needs in communication prep, social anxiety, or soft skills practice.

3. 📍 DriftMap – Ambient Exploration Web App

Concept: A generative art + map hybrid. It slowly drifts you across the globe on an abstract path with ambient music and random info snippets from locations.
Tech: Mapbox + React + audio API.
Why it's like Slow Roads: Meditative, chill, not goal-oriented – designed for low-effort engagement.

4. 📚 NoSpoil – Smart Book & Movie Tracker

Concept: Users track what they’ve watched/read and get AI-generated descriptions that **avoid spoilers.
Tech: Next.js + vector search (e.g., Pinecone or Supabase Edge functions) + OpenAI.
Why it’s useful: Solves real pain point; practical and unique AI application.

5. 🎭 MicroStory – Tiny AI-powered Story Engine

Concept: Users create short micro-stories with a few parameters (theme, tone, length), and the AI crafts a story. Can also auto-generate a matching visual.
Tech: React + OpenAI + DALL·E or 4o image generation.
Why it's resume-worthy: Combines UX, storytelling, and creativity – great to showcase frontend + API work.

6. 🧩 Fraggle – Spatial Memory Puzzle Game

Concept: A minimal, relaxing game where users memorize patterns or shapes that slowly fade and then must recreate them.
Tech: React + Canvas/WebGL (Three.js lite)
Why it's different: Casual but cognitively engaging – great for mobile too.

7. ⌛ FlowTrack – Flow State Habit Logger

Concept: Tracks when users enter "flow state" during tasks. Has a timer, mood meter, and task journal. Suggests music or lighting tweaks based on history.
Tech: Next.js + localStorage + Spotify API (optional).
Why it’s unique: Niche productivity app with behavioral design twist.

8. 🎧 EchoFeed – Personalized Soundscape Feed

Concept: Users get a scrollable feed of ambient soundscapes (generated or curated) based on their current mood or time of day.
Tech: React + Web Audio API + Supabase.
Why it’s useful: Aimed at remote workers, students, etc. for focus or chill.

Bonus: 🐌 Urban Snail – "Slow Travel" Simulator

Inspired by Slow Roads.
Concept: Simulate a slow journey across real-world cities using map/street view + procedurally generated text and ambient sound.
Tech: Next.js + Google Street View API + AI-generated travelogue narration.

null vs undefined in JavaScript: The Tale of Two Nothing

keshav Sandhu — Thu, 17 Apr 2025 16:34:01 +0000

🧩 What's the Deal with `null` and `undefined`?

In JavaScript, we have two ways to say “nothing” — but they’re not the same.

Both null and undefined represent absence, but they serve very different purposes:

🔍 The Quick Difference

Feature	`undefined`	`null`
Type	`undefined`	`object` (legacy quirk)
Set by	JavaScript (engine)	Developer (manually)
Meaning	"Not assigned yet"	"Intentionally empty"
Use Case	Missing, uninitialized values	Explicitly no value

🚀 Common Use Cases

✅ When to Use `undefined`:

Uninitialized variables

   let a;
   console.log(a); // undefined

Missing function arguments

   function greet(name) {
     console.log(name);
   }
   greet(); // undefined

Non-existent object properties

   const user = {};
   console.log(user.age); // undefined

✅ When to Use `null`:

Intentional absence of a value

   let selectedUser = null;

Resetting a variable

   input.value = null;

End of a data structure

   const node = { value: 5, next: null };

Missing elements in DOM

   const el = document.querySelector('.missing'); // null

🔥 Why Does `null` Even Matter?

Let’s say you’re sending user data:

// Using undefined
{ "middleName": undefined }  // gets stripped out in JSON.stringify

// Using null
{ "middleName": null }       // preserved: "middleName": null

✅ null = "We asked, and they don’t have a middle name."

❌ undefined = "We don’t even know if they have one."

This difference matters in:

API contracts
Database schemas
Validation logic
Conditional rendering

🤯 Gotchas and Fun Facts

null == undefined → true (loose equality)
null === undefined → false (strict equality)
typeof null → 'object' (weird, but true)

💡 TL;DR: When to Use What?

Situation	Use
Unset variable	`undefined`
Optional function argument	`undefined`
Clearing a value	`null`
End of a data structure	`null`
API says "no value" explicitly	`null`

💬 Interview-Ready Quote:

"undefined is what JavaScript gives you.

null is what you give JavaScript."

Forem: keshav Sandhu

🚀 JavaScript Async/Await vs `.then()` : The Microtask & Event Loop Secret

🧠 The Hidden Mechanism: Microtasks

⚡ What await really does

🔥 Why order matters

Version A

Version B

🧩 The Bigger Picture: Event Loop

1️⃣ Call Stack

2️⃣ Microtask Queue (High Priority)

3️⃣ Macrotask Queue (Low Priority)

⚡ Golden Rule

🧪 Full Example

🔍 Execution Flow

✅ Final Output

🎯 Final Takeaways

MongoDB vs PostgreSQL: When to Choose Which One? (With Real-World Examples)

1. MongoDB: Flexible, Schema-less, Horizontally Scalable

What MongoDB Is Great For

When to Choose MongoDB

Real-World MongoDB Projects

2. PostgreSQL: Powerful, Relational, ACID-Compliant

What PostgreSQL Is Great For

When to Choose PostgreSQL

Real-World PostgreSQL Projects

Side-by-Side Comparison

Key Takeaways & Decision Checklist

Dockerizing Node.js Microservices with Docker Compose

Why Docker for Microservices?

What We’ll Build

Folder Structure

Common Dockerfile (Node.js Service)

.dockerignore

Sample Service Code

Docker Compose (Multiple Microservices)

Environment Variables

Inter-Service Communication

Run Everything

Production-Ready Tips

Key Takeaway

MongoDB aggregation Pipelines simplified

🧱 Basic Structure

1️⃣ $match - Filtering Documents

Example:

2️⃣ $project - Select or Reshape Fields

Example:

3️⃣ $group - Group Documents & Aggregate Data

Example:

4️⃣ $sort - Sort Results

Example:

5️⃣ $limit and $skip - Pagination

Example:

6️⃣ $unwind - Deconstruct Arrays

Example:

7️⃣ $lookup - Join with Another Collection

Example:

8️⃣ $addFields - Add or Modify Fields

Example:

9️⃣ $count - Count Documents

Example:

🔟 $facet - Multiple Pipelines in One

Example:

1️⃣1️⃣ $bucket - Categorize Into Ranges

Example:

1️⃣2️⃣ $out - Write Results to a Collection

Example:

1️⃣3️⃣ $merge - Merge Results into an Existing Collection

Example:

Converting any JS project to TS backend

✅ 1. Initialize Your Node.js Project

✅ 2. Install TypeScript and Types for Node

✅ 3. Initialize TypeScript Config

Recommended tsconfig.json tweaks:

✅ 4. Create Your Project Structure

✅ 5. Compile TypeScript

✅ 6. Run the Compiled JavaScript

🔁 Optional: Add NPM Scripts

🧪 Optional: Use ts-node to Run TS Directly (without compiling)

JavaScript Object References – Explained with Examples

🔹 1. Objects Are Passed by Reference

⚡ What `await` really does

`.dockerignore`

1️⃣ `$match` - Filtering Documents

2️⃣ `$project` - Select or Reshape Fields

3️⃣ `$group` - Group Documents & Aggregate Data

4️⃣ `$sort` - Sort Results

5️⃣ `$limit` and `$skip` - Pagination

6️⃣ `$unwind` - Deconstruct Arrays

7️⃣ `$lookup` - Join with Another Collection

8️⃣ `$addFields` - Add or Modify Fields

9️⃣ `$count` - Count Documents

🔟 `$facet` - Multiple Pipelines in One

1️⃣1️⃣ `$bucket` - Categorize Into Ranges

1️⃣2️⃣ `$out` - Write Results to a Collection

1️⃣3️⃣ `$merge` - Merge Results into an Existing Collection

🧩 What's the Deal with `null` and `undefined`?

✅ When to Use `undefined`:

✅ When to Use `null`:

🔥 Why Does `null` Even Matter?