DEV Community: Abhishek Gupta

Linked List Mistakes Every Beginner Makes (Including Me)

Abhishek Gupta — Mon, 31 Aug 2026 10:17:19 +0000

Today, I spent almost 3–4 hours solving a Medium-level Linked List problem on LeetCode: Swap Nodes in Pairs.

At first, I thought the problem was simple.

The task was basically:

1 → 2 → 3 → 4

Convert it into:

2 → 1 → 4 → 3

I thought:

"Okay, I just need to swap every two nodes. How difficult can that be?"

But once I started writing the code, things became confusing.

I wrote the solution.

Got an error.

Dry-ran the code.

Found another mistake.

Changed the logic.

Created more variables.

Forgot to update a pointer.

And suddenly, my entire logic became messy. 😅

After spending hours on this one problem, I learned something important about Linked Lists.

Linked Lists are not difficult because of syntax. They are difficult because you need to understand references and pointers.

In this article, I want to share the mistakes I made and the mistakes I think almost every beginner makes while learning Linked Lists.

First, What Actually Is a Linked List?

Let's take a simple Linked List:

1 → 2 → 3 → 4 → null

Each node contains two things:

A value
A reference to the next node

We can visualize a node like this:

┌─────────┬──────────┐
│  Value  │   Next   │
└─────────┴──────────┘

For example:

┌───────┬───────┐
│   1   │   ●───┼──→ Node 2
└───────┴───────┘

The last node points to:

null

The head usually points to the first node.

head
 ↓
1 → 2 → 3 → 4 → null

Everything starts from head.

Mistake 1: Thinking a Variable Creates a New Node

This is one of the first mistakes beginners make.

Suppose we write:

let first = head;

Some beginners may think that first now contains a copy of the first node.

But that's not true.

first is simply another reference to the same node.

head ─────┐
          ↓
        [1] → [2] → [3]
          ↑
          │
first ────┘

Both head and first point to the same node.

So if you create another variable like:

let current = head;

You now have:

head ──────┐
current ───┼──→ [1] → [2] → [3]
           │
           └── Same Node

You did not create another Linked List.

You just created another reference.

Important Lesson

A variable in a Linked List usually stores a reference to a node, not a copy of the node.

Understanding this makes many Linked List problems easier.

Mistake 2: Not Understanding the Difference Between Moving a Pointer and Changing a Link

This is extremely important.

Suppose:

1 → 2 → 3 → 4

And:

let current = head;

Currently:

current
   ↓
1 → 2 → 3 → 4

Now if we write:

current = current.next;

What happens?

current moves to the next node.

1 → 2 → 3 → 4
    ↑
 current

Notice something important.

The Linked List itself did not change.

Only the variable moved.

But now look at this:

current.next = current.next.next;

This changes the actual connection between nodes.

Before:

1 → 2 → 3 → 4
↑
current

After changing current.next:

1 ─────→ 3 → 4

Node 2 has been disconnected.

So remember:

Moving a variable

current = current.next;

Means:

Move my reference.

Changing `.next`

current.next = something;

Means:

Change the Linked List structure.

This difference is very important.

Mistake 3: Accessing `.next` Without Checking for `null`

Suppose your Linked List is empty:

head = null

And you write:

let second = head.next;

This will cause an error because head does not exist.

Similarly:

1 → null

If you do:

head.next.next

You may get an error.

Because:

head.next = null

And null.next does not exist.

This is why conditions are important.

For example:

while (current && current.next) {
    // Safe to work with two nodes
}

Before accessing a node's .next, ask:

Does this node actually exist?

Mistake 4: Forgetting to Save the Next Node

This is one of the biggest mistakes when modifying a Linked List.

Suppose:

1 → 2 → 3 → 4

You are currently at node 1.

current
   ↓
1 → 2 → 3 → 4

Now imagine you change:

current.next = something;

The original connection might be lost.

For example, if you overwrite:

1 → 2

You may lose your connection to node 2.

That is why, before changing a connection, it is often useful to save the next node.

Conceptually:

let nextNode = current.next;

Now:

current → 1 → 2 → 3 → 4
              ↑
           nextNode

Even if you change current.next, you still know where node 2 is.

Simple Rule

Before breaking a connection, make sure you have saved the node you need later.

This single habit can prevent many Linked List bugs.

Mistake 5: Forgetting to Update Pointers

This was personally my biggest mistake.

While solving Swap Nodes in Pairs, I created pointers like:

prev
current
next

For example:

prev → 1 → 2 → 3 → 4
       ↑   ↑
   current next

Then I swapped 1 and 2.

After swapping:

prev → 2 → 1 → 3 → 4

The swap is complete.

But now comes the important question:

Where should my pointers go next?

Many beginners, including me, focus completely on the swap but forget to move the pointers for the next iteration.

After swapping:

prev → 2 → 1 → 3 → 4

The next pair is:

3 → 4

So our pointers need to move accordingly.

If you forget to update them, you might:

Process the same nodes again
Skip nodes
Get stuck in an infinite loop
Access the wrong node

This taught me:

Creating a pointer is easy. Updating it correctly is the difficult part.

After every operation, ask yourself:

Where is prev now?
Where is current now?
Where is next now?
Which node should I process next?

Mistake 6: Updating Pointers in the Wrong Order

In Linked Lists, the order of operations matters.

Let's say we have:

prev → first → second → remaining

And we want:

prev → second → first → remaining

There are multiple connections we need to change.

If we randomly change pointers without thinking, we can lose part of the list.

Instead, visualize every step.

Before swapping

prev → first → second → remaining

Connect `first` to remaining

first.next = second.next

Now first knows where the remaining list starts.

Connect `second` to `first`

second.next = first

Now:

second → first → remaining

Connect `prev` to `second`

prev.next = second

Final structure:

prev → second → first → remaining

The lesson here is:

Don't just write pointer operations. Understand what every line does to the structure.

Mistake 7: Not Using a Dummy Node

The first node of a Linked List is special because head points to it.

Suppose:

head
 ↓
1 → 2 → 3 → 4

After swapping the first pair:

2 → 1 → 3 → 4

Now the head needs to point to 2.

This creates an extra case.

But we can simplify this using a dummy node.

dummy → 1 → 2 → 3 → 4

Now we can treat the first pair just like every other pair.

Before:

dummy → first → second

After:

dummy → second → first

At the end:

return dummy.next;

The dummy node is not part of the final answer.

It is just a helper.

When should beginners consider a Dummy Node?

Whenever:

The head might change
You need a previous pointer before the first node
You are deleting nodes
You are inserting nodes
You are swapping nodes

A dummy node can make the logic much cleaner.

Mistake 8: Creating Too Many Variables

This is something I personally did.

When I got confused, instead of simplifying the logic, I created more variables.

Something like:

let first = ...
let second = ...
let next = ...
let temp = ...
let current = ...
let previous = ...
let third = ...

Then after some time, I forgot what each variable was supposed to do. 😅

The logic became messy in my head.

Instead, every pointer should have a clear responsibility.

For example:

prev    → Node before the pair
first   → First node of the pair
second  → Second node of the pair

That's it.

When creating a variable, ask:

Why do I need this pointer?

If you cannot answer that clearly, you probably don't need it.

Mistake 9: Losing Part of the Linked List

This is a very common problem.

Suppose:

1 → 2 → 3 → 4 → 5

You are working with:

1 → 2

But you also need to remember:

3 → 4 → 5

still exists.

If you incorrectly modify pointers, you might accidentally get:

2 → 1 → null

And the remaining nodes:

3 → 4 → 5

become disconnected.

The final answer will be wrong because you lost part of the list.

Whenever modifying nodes, think about the Linked List in three parts:

Previous | Current Nodes | Remaining Nodes

For example:

dummy → 1 → 2 | 3 → 4 → 5

Your job is to modify the current nodes while keeping the remaining list connected.

Always ask:

After changing this pointer, can I still reach the remaining nodes?

Mistake 10: Not Dry Running the Code

This was probably the thing that finally helped me solve the problem.

Initially, I was doing this:

Think → Write Code → Run

Error.

Then again:

Think → Write Code → Run

Another error.

Eventually, I stopped writing code.

I took a simple example:

1 → 2 → 3 → 4

And drew every pointer.

dummy → 1 → 2 → 3 → 4
          ↑   ↑
        first second

Then I executed one line at a time.

After every line, I asked:

What does the Linked List look like now?

This is extremely useful.

For Linked List problems:

Dry running is often more important than immediately writing code.

Take a pen and paper.

Draw boxes.

Draw arrows.

Move pointers.

You will understand the problem much faster.

Mistake 11: Forgetting How the Loop Moves Forward

In arrays, movement is easy.

for (let i = 0; i < n; i++) {
}

The index automatically moves.

But in a Linked List, you need to manually move your pointers.

For example:

while (current) {
    current = current.next;
}

The important line is:

current = current.next;

Without it, current stays in the same place.

That can cause an infinite loop.

Always ask:

Which pointer is responsible for moving through the Linked List?

And after every iteration:

Did that pointer actually move forward?

Mistake 12: Forgetting Edge Cases

Before submitting a Linked List solution, test small inputs.

Empty List

[]

One Node

Two Nodes

1 → 2

Odd Number of Nodes

1 → 2 → 3

Even Number of Nodes

1 → 2 → 3 → 4

Small test cases reveal most pointer mistakes.

For example, in Swap Nodes in Pairs:

1 → 2 → 3

The answer should be:

2 → 1 → 3

The last node should remain unchanged.

If your code assumes there are always two nodes available, it may fail.

Mistake 13: Accidentally Creating an Infinite Loop

Sometimes, while reconnecting nodes, beginners accidentally create a cycle.

For example:

1 → 2 → 3
    ↑     ↓
    └─────┘

Now if you traverse the list:

while (current) {
    current = current.next;
}

It will never reach null.

The program may run forever.

This usually happens when pointers are connected incorrectly.

After modifying a Linked List, always check:

Did I connect the correct nodes?
Did I accidentally point backward?
Can the traversal eventually reach null?

Mistake 14: Trying to Solve Everything in One Go

Sometimes beginners look at:

1 → 2 → 3 → 4 → 5 → 6

And try to understand the entire transformation at once:

2 → 1 → 4 → 3 → 6 → 5

This can be overwhelming.

Instead, break the problem into one small operation.

Focus only on:

1 → 2

Swap it:

2 → 1

Then move to:

3 → 4

Swap it:

4 → 3

Then:

5 → 6

Swap it:

6 → 5

Linked List problems become easier when you focus on a small local structure.

The Biggest Lesson I Learned

After spending almost 3–4 hours on one problem, I realized something.

My biggest problem wasn't the syntax.

It wasn't JavaScript.

It wasn't even the algorithm.

My biggest problem was:

I didn't know exactly where my pointers were pointing after every operation.

I would write some code.

Change connections.

Move some variables.

Then suddenly I would forget:

Where is current now?
Where is next now?
What happened to the previous node?
Which node should I process next?

Once I started dry-running every step, things became clearer.

My New Mental Model for Linked Lists

Now whenever I solve a Linked List problem, I divide it into three parts:

Processed | Current | Remaining

For example:

1 → 2 | 3 → 4 | 5 → 6

Suppose I am currently working on:

3 → 4

Then:

Processed       Current        Remaining

1 → 2      |    3 → 4    |    5 → 6

My job is simple:

Don't break the processed part.
Modify the current nodes.
Don't lose the remaining nodes.
Move pointers to the next position.

This way of thinking has helped me a lot.

A Simple Checklist for Linked List Problems

Before writing code, I now ask myself:

1. What does each pointer represent?

prev = ?
current = ?
next = ?

2. Can the head change?

If yes, maybe use a dummy node.

3. Can the list be empty?

head = null

4. Can there be only one node?

1 → null

5. Will changing `.next` disconnect part of the list?

Save important references first.

6. How will my pointers move forward?

Every loop iteration should make progress.

7. What is my stopping condition?

Don't access null.next.

8. Did I dry run small examples?

Always test:

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

Final Thoughts

Today, one Medium LeetCode problem took me almost 3–4 hours.

I got stuck multiple times.

I wrote the code again and again.

I made pointer mistakes.

I forgot to update references.

I made the logic complicated.

But I kept dry-running the problem until I finally understood it.

And honestly, I think spending those hours was worth it.

Because I didn't just solve one problem.

I learned how important it is to understand:

What is pointing where?

If you are a beginner learning Linked Lists, don't feel bad if they take time.

Linked Lists require visualization.

Take your time.

Draw the nodes.

Draw the arrows.

Write down your pointers.

Execute one line at a time.

And always remember:

Before changing a pointer, understand what connection you are breaking. After changing it, understand where your pointers should move next.

That's the lesson I learned today. 🚀

javascript #leetcode #dsa #datastructures #algorithms #linkedlist #programming #codingjourney #learninginpublic #beginners #100daysofcode

🏆 Software Engineering Roadmap (0 Monster)

Abhishek Gupta — Wed, 15 Jul 2026 13:00:23 +0000

Complete Learning Sequence for SDE | Backend | Full Stack | System Design | FAANG+ | Product Companies

Goal: Learn every important Computer Science and Software Engineering topic in the correct order—from absolute beginner to advanced—so you can become a world-class Software Engineer.

🟢 Phase 0 — Foundation

These subjects build your programming foundation.

1. Computer Fundamentals ⭐⭐⭐⭐⭐

History of Computers
Computer Architecture Basics
Hardware Components
Software Types
Number System
Binary
Hexadecimal
Boolean Algebra
Memory Units
CPU
RAM
Storage
Input & Output Devices

2. Programming Fundamentals ⭐⭐⭐⭐⭐

Variables
Data Types
Operators
Input / Output
Conditional Statements
Loops
Functions
Arrays
Strings
Recursion
File Handling
Exception Handling

3. Object-Oriented Programming ⭐⭐⭐⭐⭐

Classes
Objects
Constructors
Inheritance
Encapsulation
Abstraction
Polymorphism
Composition
Association
Interfaces
Generics

4. Git & GitHub ⭐⭐⭐⭐⭐

Git Basics
Repository
Clone
Commit
Branch
Merge
Rebase
Cherry Pick
Pull Requests
GitHub Flow

5. Linux ⭐⭐⭐⭐⭐

Linux Basics
File System
Permissions
Users
Groups
Shell
Bash
Process Management
Networking Commands
Package Managers

🔵 Phase 1 — Problem Solving

6. Mathematics ⭐⭐⭐⭐

Set Theory
Logic
Number Theory
Probability
Combinatorics
Big-O Mathematics

7. Aptitude ⭐⭐⭐⭐

Quantitative Aptitude

Number System
Simplification
Percentage
Profit & Loss
Discount
Ratio & Proportion
Partnership
Average
Age Problems
Time & Work
Pipes & Cistern
Time, Speed & Distance
Boats & Streams
Trains
Simple Interest
Compound Interest
Permutation & Combination
Probability
Mixture & Allegation
Logarithms
Progressions
Geometry
Mensuration
Coordinate Geometry
Trigonometry
Data Interpretation

8. Logical Reasoning ⭐⭐⭐⭐

Coding-Decoding
Blood Relations
Direction Sense
Seating Arrangement
Puzzles
Calendar
Clock
Ranking
Series
Missing Numbers
Odd One Out
Syllogism
Statement & Conclusion
Cause & Effect
Decision Making
Critical Reasoning

9. Verbal Ability ⭐⭐⭐⭐

Reading Comprehension
Grammar
Vocabulary
Synonyms
Antonyms
Sentence Correction
Error Detection
Para Jumbles
Cloze Test

🟣 Phase 2 — Data Structures & Algorithms ⭐⭐⭐⭐⭐

Data Structures

Arrays
Strings
Linked Lists
Stack
Queue
Hash Table
Heap
Tree
BST
Trie
Graph
Disjoint Set
Segment Tree
Fenwick Tree

Algorithms

Sorting
Searching
Binary Search
Sliding Window
Two Pointers
Prefix Sum
Recursion
Backtracking
Greedy
Divide & Conquer
Dynamic Programming
Bit Manipulation
Graph Algorithms
String Algorithms

🟠 Phase 3 — Core Computer Science

10. Operating Systems ⭐⭐⭐⭐⭐

Processes
Threads
Scheduling
Synchronization
Mutex
Semaphore
Deadlocks
Memory Management
Virtual Memory
Paging
Segmentation
File Systems

11. Computer Networks ⭐⭐⭐⭐⭐

Network Fundamentals
OSI
TCP/IP
IP Addressing
Routing
DNS
HTTP
HTTPS
TLS
TCP
UDP
WebSockets
CDN
Load Balancing
Reverse Proxy
Cloud Networking

12. Database Management Systems ⭐⭐⭐⭐⭐

SQL

MySQL
PostgreSQL

NoSQL

MongoDB
Redis
Cassandra

Concepts

Transactions
ACID
Indexing
Replication
Sharding
Partitioning
CAP Theorem

🔴 Phase 4 — Software Engineering

13. Software Engineering Principles ⭐⭐⭐⭐⭐

SDLC
Agile
Scrum
SOLID
DRY
KISS
YAGNI
Design Principles
Clean Code

14. Design Patterns ⭐⭐⭐⭐

Factory
Singleton
Builder
Strategy
Observer
Adapter
Decorator
Repository

🟡 Phase 5 — Backend Development ⭐⭐⭐⭐⭐

REST APIs
Authentication
Authorization
JWT
OAuth
GraphQL
gRPC
File Upload
Logging
Validation
Testing

🟢 Phase 6 — Frontend (Optional for Backend) ⭐⭐⭐⭐

HTML
CSS
JavaScript
TypeScript
React
Next.js
Accessibility
Performance

🔵 Phase 7 — Cloud & DevOps ⭐⭐⭐⭐

Docker

Kubernetes

AWS

EC2
S3
IAM
VPC
Lambda
CloudFront
Route53

CI/CD

GitHub Actions
Jenkins

🟣 Phase 8 — System Design ⭐⭐⭐⭐⭐

Capacity Estimation
Request Lifecycle
Storage
Caching
CDN
API Design
Authentication
Load Balancing
Message Queues
Distributed Systems
Reliability
Scalability
Microservices
Security
Observability
LLD
HLD

🟠 Phase 9 — Distributed Systems ⭐⭐⭐⭐⭐

CAP
PACELC
CQRS
Event Sourcing
Saga
Outbox
Raft
Paxos
Service Mesh
Distributed Locks

🔴 Phase 10 — Security ⭐⭐⭐⭐

HTTPS
TLS
Encryption
Hashing
OAuth
OWASP Top 10
XSS
CSRF
SQL Injection
CORS

🟡 Phase 11 — Testing ⭐⭐⭐⭐

Unit Testing
Integration Testing
API Testing
E2E Testing
Performance Testing

🟢 Phase 12 — Performance Engineering ⭐⭐⭐⭐

Profiling
Bottleneck Analysis
Load Testing
Stress Testing
Capacity Planning

🔵 Phase 13 — Observability ⭐⭐⭐⭐

Logging
Metrics
Tracing
Prometheus
Grafana
OpenTelemetry

🟣 Phase 14 — Engineering Excellence ⭐⭐⭐⭐

Documentation
ADR
RFC
Code Reviews
Debugging
Incident Response
Technical Debt

🟠 Phase 15 — Projects ⭐⭐⭐⭐⭐

Build progressively:

Beginner

Calculator
Todo App
Blog API

Intermediate

Authentication System
Chat Application
URL Shortener
File Storage

Advanced

Payment Gateway
Notification Service
Search Engine
Ride Sharing Backend
Video Streaming Platform
Distributed Cache
Analytics Platform

🔴 Phase 16 — Interview Preparation ⭐⭐⭐⭐⭐

DSA

300–500 Quality Problems

LLD

30–50 Problems

HLD

30–50 Designs

Behavioral

STAR Method
Leadership Principles
Communication
Resume
Mock Interviews

🏁 Final Learning Order

1. Computer Fundamentals
2. Programming Fundamentals
3. Object-Oriented Programming
4. Git & GitHub
5. Linux
6. Mathematics
7. Aptitude
8. Logical Reasoning
9. Verbal Ability
10. Data Structures
11. Algorithms
12. Operating Systems
13. Computer Networks
14. Database Management Systems
15. Software Engineering Principles
16. Design Patterns
17. Backend Development
18. Frontend (Optional)
19. Cloud Computing
20. Docker
21. Kubernetes
22. DevOps & CI/CD
23. System Design
24. Distributed Systems
25. Security
26. Testing
27. Performance Engineering
28. Observability
29. Engineering Excellence
30. Production Projects
31. Interview Preparation

Master AI: From Beginner to Advanced 🚀

Abhishek Gupta — Fri, 10 Jul 2026 04:40:21 +0000

Hello everyone! 👋

Have you ever used AI tools like ChatGPT, Gemini, Claude, GitHub Copilot, Perplexity, Microsoft Copilot, or others?

Today, AI is becoming a part of our daily lives. Students use it for learning, developers use it to write code, designers use it to generate images, and businesses use it to automate work.

But have you ever wondered...

How does AI actually work?

How can it answer our questions in just a few seconds?

Can AI answer every question in the world?

In this series, we'll learn everything about Generative AI, starting from the basics and gradually moving to advanced concepts.

🤖 What is Artificial Intelligence (AI)?

Artificial Intelligence (AI) is a technology that enables computers and machines to perform tasks that normally require human intelligence.

These tasks include:

Learning from data
Understanding language
Solving problems
Recognizing images
Writing content
Answering questions
Making predictions
Assisting humans in decision-making

In simple words,

AI is a system that learns from data and uses what it has learned to solve problems or generate responses.

🧠 How Does AI Learn?

Before an AI tool like ChatGPT, Gemini, Claude, or GitHub Copilot can answer your questions, it first needs to learn.

But unlike humans, AI doesn't go to school, attend classes, or read books like we do.

Instead, AI learns by being trained on a huge amount of data.

This data can include:

📚 Books
📰 Articles
🌐 Websites
📄 Research papers
💻 Programming code
📘 Documentation
💬 Public conversations
🖼️ Images
🎥 Videos
🎧 Audio

You can think of this as giving AI access to a very large digital library with information on many different topics.

During training, AI reads and analyzes all this data.

It doesn't try to memorize every sentence or every answer.

Instead, it learns patterns.

For example, it learns:

How people write and speak.
How grammar works.
How to solve different types of problems.
How programming languages are written.
How different ideas are connected.

The more high-quality data AI learns from, the better it becomes at understanding questions and generating useful answers.

📌 In Simple Words

Imagine you've read 1,000 books.

When someone asks you a question, you don't remember every word from those books.

Instead, you use the knowledge you've gained to think and answer.

AI works in a similar way.

It learns from a huge amount of information and then uses what it has learned to generate the best possible response.

AI doesn't simply memorize answers—it learns from lots of data, finds patterns, and uses those patterns to answer new questions.

👦 Let's Understand AI with a Simple Example

Imagine there's a boy named Ram.

Ram studies in a school where he learns:

Mathematics
Science
English
Social Studies

However, his school does not have a Computer Science subject.

After school, Ram also doesn't watch computer tutorials, read programming books, or learn from the internet.

Now imagine someone asks Ram:

"What is JavaScript?"

"How does a computer work?"

Can Ram answer these questions?

The answer is No.

Why?

Because Ram has never learned anything about computers.

He cannot answer questions about a topic he has never studied.

🤖 AI Learns in a Similar Way

AI learns in a way that's similar to how humans learn.

If an AI has never learned about a particular topic during its training, it may not be able to give the correct answer.

For example, if you ask it about something completely new that wasn't part of its training data, it might give an incorrect answer or say that it doesn't know.

However, modern AI is much more powerful than a simple question-and-answer machine.

Instead of memorizing answers, it learns patterns from the data it was trained on.

This allows AI to:

🧠 Understand your question.
🔗 Connect different pieces of knowledge.
💡 Use logic to answer questions it has never seen before.
🌐 Sometimes use the internet or other tools (if available) to find up-to-date information.

📌 In Simple Words

Think of AI as a student who has studied millions of books.

Even if the student has never seen your exact question before, they can often use what they've learned to think, connect ideas, and give a meaningful answer.

That's why AI can answer many new questions—but it can still make mistakes, especially when the information is missing, unclear, or outside what it has learned.

📚 Does AI Know Everything?

No.

AI does not know everything.

It has limitations.

For example:

It may not know very recent events if it hasn't been updated or connected to live information.
It can make mistakes or "hallucinate" incorrect information.
It may misunderstand unclear questions.
It can only answer based on what it has learned and the information available to it.

That's why it's always a good idea to verify important information from trusted sources.

Here's a beginner-friendly section with a simple ASCII diagram that explains the complete flow from a user's prompt to an AI's response. It also clarifies what LLMs and SLMs are.

🧠 How Does AI Answer Your Questions?

When you ask a question to an AI like ChatGPT, Gemini, Claude, or GitHub Copilot, a lot happens behind the scenes.

Let's understand the complete process step by step.

📌 Step 1: You Give a Prompt

Everything starts with a Prompt.

A prompt is simply the instruction, question, or message you give to the AI.

Examples

What is Artificial Intelligence?

Write a Python program to reverse a string.

Explain Newton's First Law in simple words.

The better your prompt is, the better the AI can understand what you want.

📌 Step 2: AI Understands Your Prompt

After receiving your prompt, the AI analyzes it.

It tries to understand:

What are you asking?
What information do you need?
What language should it respond in?
Should it explain, summarize, write code, or solve a problem?

This step helps the AI determine the best way to answer your request.

📌 Step 3: AI Uses What It Learned During Training

Before AI can answer questions, it must first be trained.

During training, it learns from a huge amount of data, such as:

📚 Books
🌐 Websites
📰 Articles
📄 Research papers
💻 Programming code
📘 Documentation
💬 Public conversations
🖼️ Images
🎥 Videos
🎧 Audio

Instead of memorizing every sentence, the AI learns patterns, relationships, and how language works.

When you ask a question, it uses those learned patterns to generate the most appropriate response.

📌 Step 4: AI Generates a Response

Finally, the AI predicts the next words one by one until it forms a complete answer.

It doesn't search through a giant list of stored answers.

Instead, it creates a new response based on everything it learned during training.

This is why AI can answer questions it has never seen before.

🤔 What is an LLM?

LLM stands for Large Language Model.

An LLM is an AI model trained on a very large amount of text data.

Examples include:

ChatGPT (GPT models)
Gemini
Claude
Llama
DeepSeek
Mistral

Because they learn from vast amounts of data, they can:

Answer questions
Write code
Translate languages
Summarize documents
Generate emails
Explain concepts
Solve many different tasks

Think of an LLM as a student who has read millions of books and documents.

🤏 What is an SLM?

SLM stands for Small Language Model.

It works the same way as an LLM, but it has fewer parameters and is trained to be smaller and more efficient.

SLMs are designed for:

📱 Mobile phones
💻 Laptops
🤖 Edge devices
🚗 Smart devices
Offline AI applications

Because they are smaller, they:

✅ Use less memory

✅ Are faster

✅ Cost less to run

But they may not perform as well as large models on very complex tasks.

Examples include Microsoft's Phi family and Google's Gemma family (smaller variants).

📊 LLM vs SLM

Feature	LLM (Large Language Model)	SLM (Small Language Model)
Model Size	Very Large	Small
Training Data	Huge	Smaller
Parameters	Billions (sometimes trillions in mixtures)	Millions to a few billion
Accuracy	Usually higher	Good for many tasks, but generally lower on complex reasoning
Speed	Slower	Faster
Memory Usage	High	Low
Cost	Higher	Lower
Best For	Complex reasoning, coding, research, writing	Mobile apps, edge AI, offline assistants

🚀 What Can AI Do?

Artificial Intelligence (AI) can perform many tasks that normally require human intelligence. It can understand information, learn patterns, solve problems, and help people work faster and smarter.

Here are some of the most common things AI can do:

💬 1. Answer Questions

AI can answer questions on almost any topic, such as:

Science
Mathematics
History
Geography
Programming
Business
Health (general information)
Technology

Example:

What is Artificial Intelligence?

Explain Newton's First Law.

✍️ 2. Write Content

AI can generate different types of written content, including:

Blogs
Articles
Emails
Essays
Stories
Reports
LinkedIn posts
Social media captions
Product descriptions

Example:

Write a LinkedIn post about Machine Learning.

💻 3. Write and Explain Code

AI can help developers by:

Writing code
Fixing bugs
Explaining code
Optimizing programs
Building websites
Creating APIs

It supports many programming languages, including:

Python
JavaScript
Java
C++
C#
Go
Rust
TypeScript
PHP
SQL

🌍 4. Translate Languages

AI can translate text between many languages.

For example:

English → Hindi
Hindi → English
English → French
English → Japanese

It can also explain difficult words in simple language.

📄 5. Summarize Documents

AI can quickly read long documents and provide a short, easy-to-understand summary.

Examples include:

Research papers
PDFs
Books
Reports
Meeting notes

📊 6. Analyze Data

AI can analyze large amounts of data and identify patterns.

It can help with:

Sales analysis
Business reports
Customer insights
Predictions
Trend analysis

🖼️ 7. Generate Images

Modern AI can create images from text descriptions.

For example:

"Create an image of a futuristic smart city."

It can also:

Edit photos
Remove backgrounds
Change image styles
Create logos
Design posters

🎥 8. Generate Videos

AI can create videos from text or images.

It can:

Generate animations
Create educational videos
Produce marketing videos
Create AI avatars
Generate short clips

🎙️ 9. Understand and Generate Speech

AI can:

Convert speech into text
Convert text into speech
Recognize different voices
Translate spoken language
Create natural-sounding voices

🤖 10. Build AI Assistants

AI can work as a personal assistant that helps with daily tasks.

For example, it can:

Schedule meetings
Answer emails
Set reminders
Search for information
Organize tasks
Help manage projects

🎓 11. Help Students Learn

AI is an excellent learning companion.

It can:

Explain difficult topics
Solve math problems
Generate quizzes
Create study notes
Prepare interview questions
Help with assignments

🏥 12. Help Different Industries

AI is used in many industries, including:

🏥 Healthcare
🏦 Banking
🛒 E-commerce
🚗 Automotive
🎮 Gaming
📚 Education
✈️ Travel
🎬 Entertainment
🌾 Agriculture
🏭 Manufacturing

⚡ 13. Automate Repetitive Tasks

AI can save time by automating repetitive work.

Examples:

Data entry
Email replies
Customer support
Invoice processing
Report generation
Document classification

💡 In Simple Words

Think of AI as a smart assistant.

It can:

📖 Learn from data
💬 Answer questions
✍️ Write content
💻 Write code
🌍 Translate languages
📄 Summarize information
📊 Analyze data
🖼️ Generate images
🎥 Create videos
🎙️ Understand speech
🤖 Automate tasks
🎓 Help you learn

🧠 Examples of AI Around Us

🧪 Practice Activity: Compare Different AI Models

Now it's time for a fun activity! 🎉

Don't just read about AI—experience it yourself.

Open any three AI tools:

🤖 ChatGPT
💎 Gemini
🧠 Claude
🇮🇳 Sarvam AI
💻 GitHub Copilot (for coding)
🔍 Perplexity AI

Now copy the same prompt into each AI and compare their answers.

You'll notice something interesting...

👉 Every AI gives a different answer!

Let's see why.

📝 Prompt 1: Learning

Explain Artificial Intelligence in simple words with a real-life example.

Observe:

Which AI gives the simplest explanation?
Which one gives the best example?
Which answer is easiest to understand?

💻 Prompt 2: Coding

Write a Python program to check whether a number is prime and explain each line of code.

Observe:

Which AI writes cleaner code?
Which explanation is easier to understand?
Which one teaches you better?

✍️ Prompt 3: Creative Writing

Write a short motivational story about a student who learns AI from scratch and becomes an AI Engineer.

Observe:

Which story is more creative?
Which one feels more inspiring?
Which writing style do you like the most?

🤔 Why Does Every AI Give a Different Answer?

This is one of the most common questions beginners ask.

"If I asked the same question, why didn't every AI give the same answer?"

The answer is simple.

Every AI is built differently.

Think of it like this...

Imagine three students preparing for the same exam.

Student A studies from Book A.
Student B studies from Book B.
Student C studies from Book C.

Now ask all three students the same question.

Will they all give exactly the same answer?

No.

Even though the question is the same, each student explains it differently because they learned from different books and have different ways of understanding the topic.

AI works in a very similar way.

🤖 Why Are AI Models Different?

There are several reasons:

📚 1. Different Training Data

Every AI learns from different collections of data.

Some models learn more from programming content.

Some learn more from books.

Some are better at conversations.

So each model gains different strengths.

🧠 2. Different Model Design

Every company builds its AI differently.

For example:

OpenAI built ChatGPT.
Google built Gemini.
Anthropic built Claude.
Sarvam AI is developed with a focus on Indian languages and use cases.

Each company uses its own technology and methods to train its model.

⚙️ 3. Different Training Methods

After learning from data, companies continue improving their AI.

They teach it how to:

Follow instructions better
Write more naturally
Solve problems
Write code
Stay safe and helpful

That's why some AI models give short answers, while others give detailed explanations.

🌐 4. Different Features

Some AI models can:

Search the internet
Read PDFs
Understand images
Generate images
Write code
Analyze files

Others may not support all of these features.

This also affects the quality and style of their answers.

💡 Which AI Is the Best?

There is no single "best" AI.

Every AI has its own strengths.

🤖 ChatGPT is excellent for coding, learning, and detailed explanations.
💎 Gemini works well with Google's ecosystem and multimodal tasks.
🧠 Claude is known for long documents and thoughtful writing.
💻 GitHub Copilot is specialized for programming.
🇮🇳 Sarvam AI focuses on Indian languages and local AI applications.

The best AI depends on what you want to do.

🎯 Your Challenge

Try all three prompts using three different AI models.

Then compare:

✅ Which AI explained the topic better?

✅ Which AI wrote the best code?

✅ Which AI was the most creative?

✅ Which answer did you understand the most?

There is no right or wrong answer.

The goal is to understand that every AI model has its own strengths and limitations.

The more AI tools you explore, the better you'll understand how Generative AI really works.

Don't rely on just one AI model. Try different models, compare their responses, and choose the one that best fits your task. That's what experienced AI users do! 🚀

System Design Expert

Abhishek Gupta — Thu, 09 Jul 2026 04:42:41 +0000

If your goal is to become a Senior Software Engineer, System Design Expert, or crack interviews at Google, Amazon, Microsoft, Meta, Uber, Netflix, then you should follow a structured roadmap.

The biggest mistake people make is directly jumping to "Design YouTube" or "Design WhatsApp."

Instead, System Design should be learned exactly like mathematics:

Learn Numbers → Addition → Multiplication → Algebra → Calculus

Similarly,

Learn Basics → Components → LLD → HLD → Distributed Systems → Real World Projects

🚀 Complete System Design Roadmap (0 → Monster)

                    SYSTEM DESIGN
                           │
        ┌──────────────────┴──────────────────┐
        │                                     │
      LLD                                 HLD
        │                                     │
        └──────────────┬──────────────────────┘
                       │
              Distributed Systems
                       │
              Real World Architectures
                       │
               Top Company Interviews

📚 PHASE 0 — Prerequisites

Before learning System Design, you should know:

Programming

Variables
Functions
Loops
OOP
Exception Handling

Data Structures

Array
Linked List
Stack
Queue
Tree
Graph
Heap
HashMap

Algorithms

Sorting
Searching
BFS
DFS
Dynamic Programming (Basic)
Greedy

Database Basics

Learn:

SQL
NoSQL
Primary Key
Foreign Key
Index
Joins
Transactions

Networking Basics

HTTP
HTTPS
REST API
TCP
UDP
IP Address
Port
DNS

📖 PHASE 1 — System Design Fundamentals

This is the foundation.

Without this, nothing will make sense.

Chapter 1

Introduction to System Design

What is System Design
Why learn System Design
DSA vs System Design
Client Server Architecture
Real World Examples

Chapter 2

How Internet Works

Browser
   │
DNS
   │
Load Balancer
   │
Server
   │
Database

Topics

Browser
Client
DNS
IP Address
Server
Database

Chapter 3

Scalability

Topics

Vertical Scaling
Horizontal Scaling
Peak Hours
Traffic
Resources

Chapter 4

Availability

Topics

Downtime
High Availability
Redundancy
Failover

Chapter 5

Single Point of Failure

Restaurant Example

One Chef ❌

One Server ❌

One Database ❌

Solutions

Backup
Replication
Multiple Servers

📖 PHASE 2 — Core Components

Now start learning the building blocks.

Load Balancer

Learn

Round Robin
Least Connection
Health Check
Reverse Proxy

Diagram

Users
   │
Load Balancer
   │
──────────────
│     │      │
S1    S2     S3

Database

Learn

SQL

PostgreSQL
MySQL

NoSQL

MongoDB
Cassandra

Topics

Index
Transactions
Sharding
Replication

Cache

Topics

Redis
Memcached
Cache Aside
Write Through
Write Back
TTL

Diagram

User

↓

Server

↓

Redis

↓

Database

Queue

Topics

RabbitMQ
Kafka
SQS

Learn

Producer
Consumer
Dead Letter Queue
Retry

CDN

Topics

Static Assets
Edge Server
Global Delivery

Storage

Learn

Object Storage
File Storage
Blob Storage

Example

Amazon S3

Search Engine

Topics

Elasticsearch
OpenSearch

API Gateway

Topics

Authentication
Rate Limiting
Routing

📖 PHASE 3 — Database Design

Topics

ER Diagram

Normalization

Denormalization

Indexes

Partitioning

Replication

CAP Theorem

ACID

BASE

Consistency

Availability

Partition Tolerance

📖 PHASE 4 — Low Level Design (LLD)

Now start object-oriented design.

OOP Revision

Class
Object
Encapsulation
Inheritance
Abstraction
Polymorphism

SOLID Principles

Design Principles

DRY
KISS
YAGNI

UML Diagrams

Class Diagram
Sequence Diagram
Activity Diagram
State Diagram

Design Patterns

Creational

Singleton
Factory
Builder
Prototype

Structural

Adapter
Facade
Decorator
Composite
Proxy

Behavioral

Strategy
Observer
Command
State
Iterator
Chain of Responsibility

LLD Problems

Design

Parking Lot
ATM
Library
Hotel
Cab Booking
Elevator
Snake Game
Chess
Cricbuzz
Splitwise
Vending Machine

📖 PHASE 5 — High Level Design (HLD)

Now architecture.

Topics

Scalability

Availability

Reliability

Maintainability

Fault Tolerance

Performance

Latency

Throughput

Consistency

Durability

Architecture

Monolith

Microservices

Serverless

Event Driven

Layered Architecture

Hexagonal Architecture

Clean Architecture

Communication

REST

GraphQL

gRPC

WebSocket

Message Queue

Deployment

Docker

Kubernetes

Nginx

CI/CD

Blue Green Deployment

Canary Deployment

Rolling Update

Observability

Logging

Monitoring

Tracing

Metrics

Alerting

Security

JWT

OAuth

Rate Limiting

API Gateway

Encryption

HTTPS

CORS

CSRF

XSS

SQL Injection

📖 PHASE 6 — Distributed Systems

This is where most interviews happen.

Topics

Replication

Master Slave

Leader Follower

Leader Election

Consensus

Paxos

Raft

ZooKeeper

Sharding

Horizontal Partitioning

Vertical Partitioning

Hash Based Sharding

Range Based Sharding

CAP Theorem

Consistency

Availability

Partition Tolerance

Distributed Cache

Redis Cluster

Distributed Lock

Redis Lock

ZooKeeper Lock

Event Driven Architecture

Producer

Consumer

Queue

Retry

DLQ

Streaming

Kafka

Pulsar

Event Streaming

📖 PHASE 7 — Cloud

AWS

Azure

Google Cloud

Learn

EC2

Lambda

CloudFront

RDS

DynamoDB

EKS

ECS

IAM

VPC

CloudWatch

📖 PHASE 8 — DevOps

Git

GitHub

Docker

Docker Compose

Linux

Nginx

CI/CD

GitHub Actions

Terraform (Optional)

📖 PHASE 9 — Real World Architectures

Design these systems.

Easy

✅ URL Shortener

✅ Pastebin

✅ TinyURL

Medium

✅ Chat Application

✅ Food Delivery

✅ Cab Booking

✅ Hotel Booking

✅ Instagram Feed

✅ Notification Service

Advanced

✅ WhatsApp

✅ YouTube

✅ Netflix

✅ Google Drive

✅ Dropbox

✅ Uber

✅ Google Maps

✅ Twitter/X

✅ Facebook

✅ Discord

✅ Zoom

Monster

✅ Amazon

✅ Google Search

✅ Payment Gateway

✅ Banking System

✅ Kubernetes Control Plane

📖 PHASE 10 — Interview Preparation

📖 PHASE 11 — Become a Monster

Read production-level topics.

Event Sourcing
CQRS
Saga Pattern
Outbox Pattern
Idempotency
Circuit Breaker
Bulkhead Pattern
Service Mesh
Kubernetes
Multi Region Deployment
Disaster Recovery
Zero Downtime Deployment
Blue Green Deployment
Canary Deployment
Feature Flags

🎯 Complete Learning Path (Visual Roadmap)

                           SYSTEM DESIGN
                                  │
                     ┌────────────┴────────────┐
                     │                         │
              Fundamentals                 Networking
                     │                         │
                     └────────────┬────────────┘
                                  │
                          Core Components
                                  │
       ┌──────────────┬────────────┬─────────────┐
       │              │            │             │
   Database         Cache       Queue      Load Balancer
       │              │            │             │
       └──────────────┴────────────┴─────────────┘
                                  │
                           Database Design
                                  │
                           Low Level Design
                                  │
                          Design Patterns
                                  │
                          Object-Oriented Design
                                  │
                          High Level Design
                                  │
                        Distributed Systems
                                  │
                       Cloud + DevOps + Security
                                  │
                     Real World System Design
                                  │
                    FAANG Interview Preparation
                                  │
                           Senior Engineer
                                  │
                           Staff Engineer
                                  │
                        Software Architect

📚 If You Want to Write the "World's Best System Design Notes"

I recommend organizing the notes into 30 sequential chapters, moving from beginner to advanced:

Chapter	Topic
1	Introduction to System Design
2	How the Internet Works
3	Networking Fundamentals
4	Scalability
5	Load Balancers
6	Databases
7	Database Indexing & Query Optimization
8	Caching
9	Message Queues
10	Distributed Systems
11	CAP Theorem & Consistency
12	Storage Systems
13	API Design
14	Authentication & Authorization
15	Low-Level Design (LLD)
16	SOLID Principles
17	Design Patterns
18	UML & Object Modeling
19	High-Level Design (HLD)
20	Microservices
21	Event-Driven Architecture
22	Logging, Monitoring & Observability
23	Docker & Kubernetes
24	Cloud Architecture
25	Security in Distributed Systems
26	Reliability & Fault Tolerance
27	Performance Optimization
28	Real-World Case Studies (Netflix, WhatsApp, YouTube, Uber, etc.)
29	Top Product-Based Company Interview Questions
30	Complete System Design Interview Playbook & Revision Notes

This progression mirrors how experienced engineers learn: fundamentals first, then components, then design principles, followed by architecture, distributed systems, cloud, and finally real-world interview problems. It builds a strong foundation instead of memorizing solutions.

🚀 Streaming AI Responses with Groq SDK in Node.js (Llama 3.3 70B)

Abhishek Gupta — Thu, 02 Jul 2026 04:43:39 +0000

Artificial Intelligence feels much more natural when responses appear word by word instead of waiting for the complete answer.

Groq provides one of the fastest inference APIs available today, making streaming responses incredibly smooth.

In this article, we'll build a simple streaming chatbot using the Groq SDK and the Llama 3.3 70B Versatile model.

📦 Installation

Install the official SDK.

npm install groq-sdk

🔑 Configure API Key

Create a .env file.

GROQ_API_KEY=your_api_key_here

Install dotenv if you haven't already.

npm install dotenv

📝 Complete Example

import { Groq } from "groq-sdk";
import dotenv from "dotenv/config";

const groq = new Groq({
    apiKey: process.env.GROQ_API_KEY,
});

const chatCompletion = await groq.chat.completions.create({
    model: "llama-3.3-70b-versatile",
    messages: [
        {
            role: "user",
            content: "Explain Artificial Intelligence in simple words."
        }
    ],
    temperature: 1,
    max_completion_tokens: 1024,
    top_p: 1,
    stream: true,
});

for await (const chunk of chatCompletion) {
    process.stdout.write(
        chunk.choices[0]?.delta?.content || ""
    );
}

📖 Understanding the Code

1. Import the SDK

import { Groq } from "groq-sdk";

This imports the official Groq client.

2. Create the Client

const groq = new Groq({
    apiKey: process.env.GROQ_API_KEY,
});

The SDK authenticates using your API key.

3. Send a Chat Request

const chatCompletion = await groq.chat.completions.create({
    model: "llama-3.3-70b-versatile",
    messages: [
        {
            role: "user",
            content: "Explain Artificial Intelligence in simple words."
        }
    ],
    stream: true,
});

Here we specify:

Model
User message
Streaming enabled

4. Read the Stream

for await (const chunk of chatCompletion) {
    process.stdout.write(
        chunk.choices[0]?.delta?.content || ""
    );
}

Instead of waiting for the whole response, each token is printed immediately.

Output looks like this:

Artificial Intelligence (AI) is...
...technology that allows...
...computers to learn...
...and solve problems...

This creates a ChatGPT-like typing effect.

⚙️ Parameters Explained

Parameter	Description
`model`	AI model to use
`messages`	Conversation history
`temperature`	Controls creativity
`top_p`	Controls token sampling
`max_completion_tokens`	Maximum output length
`stream`	Enables real-time streaming

💡 Why Use Streaming?

Streaming provides several advantages:

⚡ Faster perceived response time
😊 Better user experience
💬 ChatGPT-like interface
📉 Reduced waiting time
🔄 Real-time updates

For chat applications, streaming is almost always the preferred approach.

🏗️ Perfect For

This pattern works great for building:

AI Chatbots
Customer Support Assistants
Coding Assistants
AI Terminal Applications
Documentation Assistants
AI Agents
Personal Assistants

🚀 Example Output

User:
What is Machine Learning?

AI:
Machine Learning is a branch of Artificial Intelligence that enables computers to learn patterns from data without being explicitly programmed...

The text appears progressively as the model generates it.

🚀 Sarvam AI Complete Guide for Beginners (JavaScript + Python)

Abhishek Gupta — Thu, 02 Jul 2026 04:12:54 +0000

What is Sarvam AI?

Sarvam AI is an Indian Generative AI platform that provides Large Language Models (LLMs), speech AI, translation, voice agents, and AI APIs for developers.

Think of Sarvam AI as India's version of services like:

OpenAI
Anthropic
Google Gemini

Using Sarvam APIs, developers can:

Build AI chatbots
Generate text
Summarize documents
Translate Indian languages
Create voice assistants
Build customer support systems
Integrate AI into websites and mobile apps

Why Use Sarvam AI?

Benefits

✅ Indian Language Support

✅ Simple API Integration

✅ Fast Response

✅ Production Ready

✅ Multiple AI Models

✅ Voice and Speech Capabilities

✅ Developer Friendly SDKs

Architecture Overview

User → Your Application → Sarvam API → AI Model → Response

Example:

User asks:

"Explain Artificial Intelligence"

Your backend sends request to Sarvam.

Sarvam processes the request using an LLM.

The AI generates an answer.

The answer is returned to your application.

Step 1: Create a Sarvam Account

Visit:

Sarvam AI Platform

Create an account using:

Google Login
Email Login

After verification, access the developer dashboard.

Step 2: Generate an API Key

After login:

Open Dashboard
Go to API Keys
Click Create API Key
Copy the generated key

Example:

sk_xxxxxxxxxxxxxxxxxxxxx

⚠️ Never expose your API key publicly.

Bad:

const apiKey = "sk_xxxxxxxxx";

Good:

SARVAM_API_KEY=sk_xxxxxxxxx

Step 3: Install SDK

JavaScript / Node.js

npm install sarvamai

yarn add sarvamai

Python

pip install sarvamai

Understanding Chat Completions

A Chat Completion API allows you to send messages to an AI model and receive a response.

Example:

User:
What is Machine Learning?

AI:
Machine Learning is a branch of AI...

JavaScript Example

Basic Setup

import { SarvamAIClient } from "sarvamai";

const client = new SarvamAIClient({
  apiSubscriptionKey: process.env.SARVAM_API_KEY,
});

Complete Example

import { SarvamAIClient } from "sarvamai";
import dotenv from "dotenv";

dotenv.config();

const client = new SarvamAIClient({
  apiSubscriptionKey: process.env.SARVAM_API_KEY,
});

async function main() {
  try {
    const response = await client.chat.completions({
      model: "sarvam-30b",
      messages: [
        {
          role: "user",
          content: "Explain the significance of the Indian monsoon season.",
        },
      ],
      temperature: 0.5,
      top_p: 1,
      max_tokens: 1000,
    });

    console.log(response.choices[0].message.content);
  } catch (error) {
    console.error(error);
  }
}

main();

Understanding Every Parameter

model

model: "sarvam-30b"

Specifies which AI model to use.

Think of it as selecting the AI brain.

messages

messages: [
  {
    role: "user",
    content: "Hello"
  }
]

Conversation history sent to the AI.

role

Three common roles:

user

Question from user.

{
  role: "user",
  content: "What is AI?"
}

assistant

Previous AI response.

{
  role: "assistant",
  content: "AI stands for Artificial Intelligence."
}

system

Instructions for AI behavior.

{
  role: "system",
  content: "You are a helpful teacher."
}

temperature

temperature: 0.5

Controls creativity.

Low Temperature

temperature: 0.1

More factual and predictable.

Medium Temperature

temperature: 0.5

Balanced output.

High Temperature

temperature: 1

More creative responses.

top_p

top_p: 1

Controls how many probable words can be selected.

Example

Predictions:

Coffee = 40%
Tea = 30%
Milk = 20%
Water = 10%

If:

top_p = 0.8

AI may only consider:

Coffee
Tea
Milk

max_tokens

max_tokens: 1000

Maximum response length.

Higher value:

Longer answers
Higher cost
More tokens consumed

Multi-Turn Conversation

const response = await client.chat.completions({
  model: "sarvam-30b",
  messages: [
    {
      role: "system",
      content: "You are a helpful coding mentor.",
    },
    {
      role: "user",
      content: "What is JavaScript?",
    },
    {
      role: "assistant",
      content: "JavaScript is a programming language.",
    },
    {
      role: "user",
      content: "Give me an example.",
    },
  ],
});

The AI remembers previous messages in the conversation.

Python Example

Basic Setup

from sarvamai import SarvamAIClient
import os

client = SarvamAIClient(
    api_subscription_key=os.getenv("SARVAM_API_KEY")
)

Complete Python Example

from sarvamai import SarvamAIClient
import os

client = SarvamAIClient(
    api_subscription_key=os.getenv("SARVAM_API_KEY")
)

response = client.chat.completions(
    model="sarvam-30b",
    messages=[
        {
            "role": "user",
            "content": "Explain Artificial Intelligence"
        }
    ],
    temperature=0.5,
    top_p=1,
    max_tokens=500
)

print(response.choices[0].message.content)

Express.js API Example

Create your own AI endpoint.

import express from "express";
import dotenv from "dotenv";
import { SarvamAIClient } from "sarvamai";

dotenv.config();

const app = express();

app.use(express.json());

const client = new SarvamAIClient({
  apiSubscriptionKey: process.env.SARVAM_API_KEY,
});

app.post("/chat", async (req, res) => {
  try {
    const { message } = req.body;

    const response = await client.chat.completions({
      model: "sarvam-30b",
      messages: [
        {
          role: "user",
          content: message,
        },
      ],
    });

    return res.json({
      success: true,
      response: response.choices[0].message.content,
    });
  } catch (error) {
    return res.status(500).json({
      success: false,
      error: error.message,
    });
  }
});

app.listen(3000);

Error Handling

Always use try-catch.

try {
  const response = await client.chat.completions({
    model: "sarvam-30b",
    messages,
  });
} catch (error) {
  console.error(error);
}

Common errors:

Invalid API Key

401 Unauthorized

Rate Limit

429 Too Many Requests

Server Error

500 Internal Server Error

Best Practices

Use Environment Variables

SARVAM_API_KEY=your_key

Validate Input

if (!message) {
  return res.status(400).json({
    error: "Message required",
  });
}

Limit Token Usage

max_tokens: 300

Prevents unnecessary cost.

Add Logging

console.log("Request received");

Useful for debugging.

Real-World Use Cases

Customer Support Bot

User → Question
AI → Answer

Internal Company Assistant

Employees → Ask Questions
AI → Company Knowledge

FAQ Generator

Document → AI
AI → FAQ List

Content Generation

Topic → AI
AI → Blog Post

Education Platform

Student Question → AI
AI → Explanation

How YouTube Recommends Videos: Learn Machine Learning Without Writing Code

Abhishek Gupta — Thu, 25 Jun 2026 07:59:59 +0000

🎯 Goal

After this activity, you should understand:

✅ What is Data

✅ What is a Dataset

✅ What is Training Data

✅ What is a Feature

✅ What is Training

✅ What is Prediction

✅ Why ML needs lots of examples

✅ How YouTube recommends videos

Step 1 — Ask a Simple Question

Imagine you open YouTube.

You watch:

Python Tutorial

A few seconds later, YouTube suggests:

React Tutorial
JavaScript Course
Node.js Crash Course

Question:

How did YouTube know that you might like React?

Did an Engineer Write This?

if user == "Abhishek":
    recommend("React Tutorial")

No.

That would never work.

Why?

Because YouTube has:

Billions of users
Millions of videos
Billions of views every day

No engineer can write rules for every person.

Machine Learning solves this problem.

Step 2 — What Does YouTube Collect?

Machine Learning needs examples.

These examples come from data.

YouTube collects things like:

Information	Example
Video watched	Python Basics
Watch time	15 minutes
Like	Yes
Comment	Nice video
Search	React Tutorial
Device	Mobile
Country	India
Subscribed	Yes

Think Like a Teacher

A teacher teaches students using examples.

Machine Learning also learns from examples.

The only difference is:

Teacher → Students

Data → Machine

Step 3 — Give Data to the Machine

This is called Training Data.

We are teaching YouTube.

Dataset:

User	Watched Video	Next Video
User1	Python Basics	React Tutorial
User2	Python Basics	React Tutorial
User3	Python Basics	Node.js
User4	Python Basics	React Tutorial
User5	Cricket Match	Highlights
User6	AI News	ChatGPT Tutorial
User7	AI News	Prompt Engineering
User8	Cooking Pasta	Cake Recipe

Important Idea

This table is called a Dataset.

Machine Learning studies this dataset.

Step 4 — Become the Machine

Forget computers.

You are now the ML model.

Look only at Python.

Examples:

Python → React

Python → Node.js

Python → React

Count them.

React = 3 times

Node.js = 1 time

Step 5 — Learn the Pattern

Machine says:

I noticed something.

People who watch Python usually watch React.

Pattern learned:

Python
   ↓
React

Step 6 — Training

Training simply means:

Study examples.

Again.

Until patterns become clear.

Machine Learning Training = Studying examples.

Step 7 — Prediction

A new user comes.

Watched:

Python Basics

Machine asks:

What did similar people watch?

Answer:

React Tutorial

Recommendation:

🎯 React Tutorial

Step 8 — Confidence

Machine may think:

React = 80%

Node.js = 15%

Angular = 5%

Best choice?

React.

Step 9 — More Data Makes Better ML

Suppose we train with:

10 users

Model is okay.

Train with:

10 million users

Model becomes much smarter.

Step 10 — Real YouTube

Real YouTube studies:

Billions of videos watched

Likes

Comments

Searches

Subscriptions

Watch time

Devices

Countries

Age groups

Student Activities

Activity 1

Open Excel.

Create the dataset.

Count recommendations.

Activity 2

Add 20 more users.

Example:

Python → Vue

Python → Angular

Python → React

See what changes.

Activity 3

Predict recommendations.

User watched:

AI News

Recommend what?

Activity 4

Create your own recommendation system.

Topics:

Sports

Music

Movies

Travel

Gaming

Teach the machine.

Questions for Students

Q1

What is Data?

Q2

What is a Dataset?

Q3

Why does ML need examples?

Q4

What is Training?

Q5

What is Prediction?

Q6

Why can't YouTube use if-else statements?

Q7

Does more data improve recommendations?

Why?

MCQs

1. What does Machine Learning learn from?

A) Luck

B) Examples

C) Guessing

D) Passwords

✅ Answer: B

2. What is a Dataset?

A) A game

B) A collection of examples

C) A password

D) A website

✅ Answer: B

3. What is Training?

A) Writing code

B) Studying examples

C) Buying GPUs

D) Guessing answers

✅ Answer: B

The Most Important Lesson

Traditional Programming:

Human writes rules
        ↓
Computer follows rules

Machine Learning:

Examples
   ↓
Find patterns
   ↓
Learn relationships
   ↓
Make predictions
   ↓
Improve with more data

One Sentence to Remember

Machine Learning is simply teaching a computer by showing it many examples, just like teaching a child by showing many pictures, videos, or experiences.

How One Linked List Problem Challenged Everything I Thought I Knew

Abhishek Gupta — Tue, 23 Jun 2026 18:34:37 +0000

Today, I spent several hours debugging a Linked List problem, and by the end of it, I gained a much deeper understanding of references, pointers, and why some patterns exist in the first place.

🔗 Current Problem: Merge Two Sorted Lists

Before starting this problem, I was feeling confident because I had already solved Add Two Numbers by directly modifying the original linked list instead of creating a completely new one.

My solution:
https://leetcode.com/problems/add-two-numbers/solutions/8345486/add-two-numbers-using-in-place-modificat-no1j

In that problem, I reused the existing nodes, updated values in-place, and only created new nodes when absolutely necessary.

List1.val = sum % 10;

If the list ended and there was still a carry:

prev.next = new ListNode(rem);

The approach worked beautifully.

The solution was accepted, and more importantly, I understood why it worked.

So when I started Merge Two Sorted Lists, my first thought was:

"Why create a dummy node? I already solved Add Two Numbers by modifying the original linked list. I should be able to do the same thing here."

That assumption sent me into one of the longest debugging sessions I've had recently.

My Initial Approach

Given:

list1 = 1 -> 2 -> 4
list2 = 1 -> 3 -> 4

Expected:

1 -> 1 -> 2 -> 3 -> 4 -> 4

My plan seemed straightforward:

Traverse both lists.
Compare values.
Insert nodes where necessary.
Modify list1 directly.
Return the modified list.

Simple.

At least that's what I thought.

Hours of Debugging Later...

I wrote the code.

Ran test cases.

Failed.

Added logs.

Failed again.

Added more logs.

Still failed.

Then I started manually dry-running every iteration.

I opened Excalidraw and literally drew:

Every node
Every pointer
Every insertion
Every reference update

And that's when I finally noticed what was actually happening.

The Mistake Wasn't In My Logic

The mistake was in my understanding.

While traversing the linked list, I kept moving my pointers:

head1 = head1.next;
head2 = head2.next;

I was using the same variable for two completely different responsibilities:

Keeping track of the original head.
Traversing the list.

Example:

head1
 ↓
1 -> 2 -> 4

After:

head1 = head1.next;

head1
 ↓
2 -> 4

Again:

head1 = head1.next;

head1
 ↓
4

Again:

head1 = head1.next;

head1
 ↓
null

At that moment, I realized something important:

I had completely lost the reference to the beginning of the list.

And once a reference is lost in a linked list, there's no way to magically get it back.

Why My Add Two Numbers Approach Worked

This was the breakthrough moment.

In Add Two Numbers, I wasn't changing the structure of the linked list.

I was only modifying values.

List1.val = sum % 10;

The nodes stayed connected.

The original head never changed.

The linked list structure remained intact.

So modifying the original list worked perfectly.

Why The Same Idea Fails Here

In Merge Two Sorted Lists, the situation is completely different.

We are not simply updating values.

We are:

Connecting nodes from two different linked lists.
Rearranging node relationships.
Managing multiple references.
Building an entirely new traversal path.

This means reference management becomes more important than the comparison logic itself.

A single lost reference can disconnect part of the list.

A single incorrect pointer update can break the entire structure.

That's exactly what I was running into during debugging.

The Moment Dummy Nodes Finally Made Sense

Earlier, I used to think:

"Dummy nodes are just an extra step."

Now I understand why they're one of the most common patterns in Linked List problems.

let dummy = new ListNode(-1);
let current = dummy;

The dummy node provides a permanent starting point.

No matter how many times I move pointers:

current = current.next;

I can always access the merged list through:

dummy.next;

Benefits:

✅ Never lose the head reference

✅ No special handling for the first node

✅ Cleaner insertion logic

✅ Easier debugging

✅ Cleaner interview solution

Biggest Lessons From Today

Technical Lessons

✅ Difference between modifying node values and modifying node connections

✅ Why preserving references is critical in Linked Lists

✅ Why Add Two Numbers and Merge Two Sorted Lists require different thinking

✅ How easily a head pointer can be lost

✅ Why Dummy Nodes are used so frequently

✅ The importance of visual dry runs

Non-Technical Lessons

Today reminded me that solving problems isn't always about writing more code.

Sometimes progress looks like:

Writing code
Failing
Debugging
Drawing diagrams
Questioning assumptions
Understanding why your approach doesn't work

The most valuable part of today's session wasn't finding the answer.

It was understanding why my original answer failed.

Tomorrow's Goal 🎯

Tomorrow I'll solve Merge Two Sorted Lists again, this time using the Dummy Node pattern and building the merged linked list step by step while preserving all references correctly.

I didn't get an accepted solution today.

But I gained something more valuable:

A much deeper understanding of how Linked Lists actually work under the hood.

And that's a win I'll happily take.

100DaysOfCode #Day747 #LeetCode #DSA #JavaScript #LinkedList #Debugging #ProblemSolving #SoftwareEngineering #CodingJourney #LearnInPublic #WebDevelopment

🚀 React Hook Form: From Beginner to Monster — Everything You Need to Know

Abhishek Gupta — Mon, 22 Jun 2026 06:33:37 +0000

I spent several days debugging React Hook Form, understanding why some components rerender while others don't, learning about subscriptions, Proxies, Controllers, FormProvider, useFormState, and the internals that make RHF one of the fastest form libraries in the React ecosystem.

This article contains everything I wish someone had explained when I started.

If you understand all of these concepts, you'll not only become productive with RHF but also gain a deeper understanding of React rendering, subscriptions, and state management.

Let's begin.

Why React Hook Form Exists

Most React developers start with this approach:

const [name, setName] = useState("");

<input
    value={name}
    onChange={(e) => setName(e.target.value)}
/>

This works fine for a few fields.

But imagine building:

Login Form
Signup Form
Admin Dashboard
Course Creation Page
E-commerce Product Form
Job Portal
CMS
Dynamic Forms

Suddenly you have:

const [name,setName]
const [email,setEmail]
const [password,setPassword]
const [errors,setErrors]
const [isDirty,setDirty]
const [touched,setTouched]

The code becomes messy.

Every keystroke rerenders components.

Validation logic becomes difficult.

Performance suffers.

React Hook Form solves these problems.

Why React Hook Form is Fast

Most libraries use:

useState()

RHF uses:

Uncontrolled Components

Instead of storing every keystroke inside React State,

RHF stores values inside refs.

This means:

Typing:

a
ab
abc
abcd

does NOT rerender the entire component tree.

This is the secret sauce.

useForm()

The most important hook.

const methods = useForm();

It returns:

register
handleSubmit
watch
control
formState
reset
setValue
getValues
trigger
setError
clearErrors
resetField
setFocus

register()

Simplest way to connect an input.

<input

{...register("name")}

/>

RHF internally adds:

value

onChange

onBlur

ref

Automatically.

Validation

Simple validation

register(

"name",

{

required:true

}

)

Advanced

register(

"name",

{

required:"Name required",

minLength:{

value:3,

message:"Minimum 3"

}

}

)

Zod Integration

Install

npm i zod
npm i @hookform/resolvers

Schema

const Schema=z.object({

name:

z.string()

.min(

1,

"Required"

)

});

Hook

useForm({

resolver:

zodResolver(

Schema

)

})

handleSubmit()

const submit=(data)=>{

console.log(data);

};



<form

onSubmit={

handleSubmit(

submit

)

}

>

Error callback

const onError=(errors)=>{

console.log(errors);

};



handleSubmit(

submit,

onError

);

watch()

Subscribe to field values.

watch("email");

Example

const title=

watch(

"courseName"

);

When title changes,

Component rerenders.

useWatch()

Optimized version.

const title=useWatch({

control,

name:"courseName"

});

Only rerenders for this field.

Best for large applications.

getValues()

Read values.

No rerender.

getValues();

Single

getValues(

"email"

);

setValue()

Programmatically update.

setValue(

"name",

"Abhishek"

);

Options

setValue(

"name",

"John",

{

shouldValidate:true,

shouldDirty:true,

shouldTouch:true

}

);

reset()

reset();

Default

reset({

name:"John"

});

trigger()

Validate manually.

await trigger();

Specific

await trigger(

"email"

);

setError()

Custom validation.

setError(

"email",

{

message:"Email exists"

}

);

clearErrors()

clearErrors();

Specific

clearErrors(

"email"

);

Controller()

For custom components.

Bad

<Input

value={watch()}

onChange={()=>setValue()}

/>

Good

<Controller

name="title"

control={control}

render(

{

field,

fieldState

}

)=>(


<Input


value={field.value}

onChange={field.onChange}

error={fieldState.error?.message}


/>

)

}

/>

fieldState

Inside Controller

fieldState.error


fieldState.invalid


fieldState.isTouched

Automatic subscription.

useFieldArray()

Dynamic forms.

Perfect for:

Skills

Projects

Education

Requirements

Admission Criteria

Example

const{

fields,

append,

remove

}=

useFieldArray({

control,

name:"skills"

});

Add

append({

value:""

});

Delete

remove(index);

FormProvider

Best architecture.

Wrapper

<FormProvider

{...methods}

>

<App/>

</FormProvider>

Consume

const methods=

useFormContext();

The Biggest Confusion: formState

Everyone writes:

const{

formState:{

errors

}

}=methods;

Sometimes

Errors update.

Sometimes

Component doesn't rerender.

Why?

formState is NOT Normal State

It's a

Proxy.

Something similar to:

new Proxy(

state,

{

get(){

subscribe();

}

}

)

RHF only rerenders subscribers.

Why My Component Didn't Rerender?

I had:

const methods=

useCourseFormContext();



console.log(

methods.formState.errors

);

Validation happened.

Errors existed.

But component never rerendered.

Solution

Subscribe.

const{

errors

}=

useFormState({

control

});

Now

Errors change

↓

Component rerenders

Instantly.

useFormState()

Perfect for:

errors


isDirty


isValid


dirtyFields


touchedFields


submitCount

Example

const{

errors,

isDirty,

isValid

}=

useFormState({

control

});

Validation Modes

onSubmit

mode:"onSubmit"

Only submit.

onChange

mode:"onChange"

Validate every key.

onBlur

mode:"onBlur"

Validate after blur.

all

mode:"all"

Everything.

Performance Tips

Use

✅ register

✅ Controller

✅ fieldState

✅ useWatch

✅ useFormState

✅ useFieldArray

✅ FormProvider

Avoid

❌ watch everywhere

❌ setValue everywhere

❌ Multiple useForm()

❌ Manual states

❌ Copying RHF data into useState

Interview Questions

Why is RHF fast?

Because it uses uncontrolled components, refs, subscriptions, and Proxy-based formState instead of storing every field in React state.

Difference between watch and useWatch?

watch rerenders the parent component.

useWatch subscribes only to selected fields.

Difference between Controller and register?

Controller is designed for custom controlled components.

Why useFormState?

To subscribe components to errors, dirty state, touched fields, and validity changes.

Why FormProvider?

To avoid prop drilling and share the same form instance across deeply nested components.

Final Thoughts

React Hook Form isn't just another form library.

It's a carefully designed subscription-based state management system optimized specifically for forms.

🚀 BCA E-Commerce & E-Governance: Complete One-Day Revision Guide (0 to Monster)

Abhishek Gupta — Wed, 03 Jun 2026 05:11:21 +0000

If you're a BCA student preparing for your E-Commerce & E-Governance exam and only have a day left, this guide is for you.

Instead of reading hundreds of pages, focus on the topics that repeatedly appear in exams and form the core of the syllabus.

📚 Unit 1: Introduction to E-Commerce

What is E-Commerce?

E-Commerce (Electronic Commerce) is the buying and selling of goods and services through electronic networks such as the Internet.

Examples

Amazon
Flipkart
Myntra
Meesho

Advantages of E-Commerce

Global reach
24×7 availability
Lower operational cost
Faster transactions
Better customer service

Disadvantages of E-Commerce

Security risks
Privacy issues
Internet dependency
Delivery delays
No physical inspection of products

Business Models of E-Commerce

B2B (Business to Business)

A business sells products or services to another business.

Example

Alibaba, IndiaMART

B2C (Business to Consumer)

A business sells directly to customers.

Example

Amazon, Flipkart

C2C (Consumer to Consumer)

Consumers sell products to other consumers.

Example

OLX, eBay

C2B (Consumer to Business)

Consumers provide products or services to businesses.

Example

Upwork, Freelancer

Ethical Issues in E-Commerce

Privacy violation
Online fraud
Fake reviews
Spam emails
Intellectual property theft

Solutions

Data encryption
Privacy policies
Secure payment systems
Cyber laws
User awareness

Electronic Data Interchange (EDI)

EDI is the electronic exchange of business documents between organizations using a standard format.

Benefits

Reduces paperwork
Improves accuracy
Faster communication
Lower cost

Value Chain

A sequence of activities that add value to a product or service.

Activities

Production
Marketing
Sales
Customer Service

Supply Chain

The movement of products from suppliers to customers.

Flow

Supplier → Manufacturer → Distributor → Retailer → Customer

📚 Unit 2: Electronic Payment Systems

Electronic Payment System (EPS)

An Electronic Payment System allows money transfer without using physical cash.

Examples

UPI
Credit Card
Debit Card
Paytm Wallet
Net Banking

Payment Gateway

A payment gateway securely processes online transactions.

Examples

Razorpay
Stripe
PayU

Credit Card

Allows users to buy now and pay later.

Example

Visa Credit Card

Debit Card

Money is deducted directly from the user's bank account.

Example

RuPay Debit Card

Smart Card

A card containing an embedded microchip.

Example

Metro Smart Card

E-Credit Accounts

Digital credit facilities used for online purchases.

Examples

Credit Cards
Amazon Pay Later

Importance

Cashless transactions
Easy online shopping
Fast payments
Better transaction records

E-Money

Money stored electronically for online transactions.

Example

Paytm Wallet

Internet Banking

Internet Banking allows customers to access banking services through the Internet.

Features

Fund transfer
Balance inquiry
Bill payment
Account statements
Loan services

Advantages

24×7 banking
Saves time
Convenient
Paperless banking

M-Commerce

Mobile Commerce refers to commercial transactions conducted through mobile devices.

Examples

Google Pay
PhonePe
BHIM

Categories of E-Commerce

Issues in E-Commerce

Security threats
Privacy concerns
Payment failures
Legal issues
Delivery challenges

📚 Unit 3: E-Governance

What is E-Governance?

E-Governance is the use of Information and Communication Technology (ICT) to provide government services electronically.

Examples

DigiLocker
UMANG
Online Passport Services

Benefits of E-Governance

Transparency
Faster service delivery
Reduced corruption
Better accessibility
Increased accountability

Evolution of E-Governance

Information Stage
Interaction Stage
Transaction Stage
Transformation Stage

Issues in E-Governance Applications

Digital divide
Lack of awareness
Poor infrastructure
Security concerns
Resistance to change

E-Governance Models

Broadcasting Model

Government shares information with citizens.

Example

Government portals

Critical Flow Model

Important information reaches targeted groups.

Example

RTI information

Comparative Analysis Model

Compares government performance.

Example

State ranking reports

Mobilization and Lobbying Model

Encourages public participation.

Example

Online campaigns

Interactive Service Model (G2C2G)

Two-way communication between government and citizens.

Example

Online complaint portals

📚 Unit 4: Advanced E-Governance

E-Readiness

The ability of a country or organization to effectively use digital technologies.

E-Government Readiness

Measures how prepared a government is for digital governance.

Factors

Infrastructure
Digital literacy
Internet availability

E-Framework

A structured approach to implementing e-governance.

Steps

Requirement analysis
Infrastructure setup
Security planning
Implementation
Monitoring

Data Warehousing

A centralized repository for storing large volumes of data.

Benefits

Historical analysis
Better decision making
Easy access to information

Data Mining

The process of extracting useful information from large datasets.

Applications

Tax fraud detection
Crime analysis
Healthcare planning
Welfare scheme monitoring

NICNET

National Informatics Centre Network.

Role

Provides nationwide networking support for government departments.

E-Seva

An e-governance initiative providing multiple services through a single platform.

Origin

Andhra Pradesh

Significance

Transparency
Faster services
Citizen convenience
Reduced corruption

Digital Payment Platforms

UPI
BHIM
Google Pay
PhonePe
Paytm

Use of Aadhaar in Digital Services

e-KYC
Identity verification
Bank account linking
Direct Benefit Transfer (DBT)

📚 Unit 5: E-Government Security

E-Security

Protection of electronic systems, networks, and data from unauthorized access.

Risks in E-Business

Hacking
Malware
Phishing
Data theft
DDoS attacks

Security Measures

Firewalls
Antivirus software
Encryption
Strong passwords
Two-factor authentication

Communication Channel Security

Protection of data while it travels through networks.

Importance

Confidentiality
Integrity
Authentication

Technologies

HTTPS
SSL
TLS
VPN

Security for Server Computers

Firewall protection
Access control
Backup systems
Regular updates

Security for Client Computers

Antivirus software
Secure passwords
Software updates

Information Technology Act, 2000

The IT Act 2000 provides legal recognition to electronic transactions and digital records in India.

Highlights

Digital signatures
Electronic contracts
Cybercrime provisions
E-commerce support
E-governance support

Firewall

A security system that monitors and controls incoming and outgoing network traffic.

Purpose

Prevents unauthorized access.

E-Shop

An online store where products and services are sold through the Internet.

Examples

Amazon
Flipkart
Myntra

Building CommDesk — From Chaos to a Production-Grade Community Management Platform 🚀

Abhishek Gupta — Tue, 26 May 2026 15:48:01 +0000

Links 🔗

Commdesk Desktop Application Repository Link

https://github.com/NexGenStudioDev/CommDesk

Commdesk Backend Repository Link

https://github.com/NexGenStudioDev/CommDesk-Backend

Every developer community starts with passion.

But as communities grow, operations become messy.

Google Forms for registrations.
Discord for communication.
Sheets for tracking.
Notion for tasks.
Random WhatsApp groups for coordination.
Different dashboards for sponsors, events, and volunteers.

Eventually, everything becomes fragmented.

That problem is exactly why I started building CommDesk.

What is CommDesk?

CommDesk is a modern open-source desktop platform built to help communities manage:

Events
Hackathons
Teams
Sponsors
Partnerships
Internal Operations
Fund Management
Community Workflows

All from a single workspace.

The goal was simple:

Replace scattered community operations with one powerful platform.

The Problem

Most developer communities and student organizations face the same issues:

❌ Scattered Tools

One tool for registrations.
Another for communication.
Another for sponsorships.
Another for approvals.

No centralized workflow.

❌ Poor Event Coordination

Managing hackathons manually becomes painful:

Participant tracking
Team management
Sponsor approvals
Fund requests
Volunteer coordination

Everything becomes operational chaos.

❌ No Proper Sponsor Management

Sponsors are the backbone of events.

Yet most communities still track sponsors in spreadsheets.

No:

Sponsor lifecycle tracking
Renewal management
Partnership workflows
Sponsorship analytics
Approval pipelines

❌ Community Scaling Problems

A small community can survive with manual systems.

A large one cannot.

As operations grow:

coordination breaks
transparency reduces
approvals slow down
management becomes difficult

That’s where CommDesk comes in.

The Vision Behind CommDesk

I didn’t want to build just another CRUD dashboard.

I wanted to build:

A real operational system for communities.

Something that feels like:

Linear for communities
Jira for event operations
Notion for coordination
CRM for sponsors
Admin suite for hackathons

All combined together.

Core Features

🎯 Community Management

Manage entire communities from one dashboard:

Members
Roles
Permissions
Teams
Operations
Event participation

🏆 Hackathon Management

Hackathons are extremely difficult to manage manually.

CommDesk includes:

Team creation
Participant tracking
Event operations
Approval systems
Internal workflows
Dashboard analytics

🤝 Sponsorship Operations Dashboard

One of the biggest modules.

Includes:

Sponsor management
Partnership requests
Sponsor lifecycle tracking
Renewal systems
Fund dispatch management
Approval workflows
Sponsor activity analytics

This transforms sponsor handling from spreadsheets into a proper system.

💰 Fund Request & Approval System

Communities constantly manage budgets manually.

CommDesk introduces:

Fund request forms
Approval pipelines
Event fund dispatch
Finance tracking
Request statuses
Operational transparency

📊 Analytics Dashboard

Everything should be measurable.

CommDesk provides analytics for:

Events
Community growth
Sponsorships
Team activities
Operations
Participation

Tech Stack ⚡

I wanted modern performance + scalability.

So the stack includes:

Frontend

React
TypeScript
Tailwind CSS

Desktop Layer

Tauri

Why Tauri?

Because Electron is powerful, but often heavy.

Tauri gives:

smaller bundles
better performance
lower memory usage
native feel

Backend

Node.js
Express.js

Focused on scalable APIs and modular architecture.

Database

MongoDB

Chosen for flexible schema handling and fast iteration during rapid feature development.

Why Desktop Instead of Web?

Most people asked me this.

The answer is simple.

Communities and operational teams often need:

persistent workflows
better local performance
desktop-style management systems
app-like experience

A desktop-first workflow feels significantly better for operations-heavy platforms.

Challenges While Building CommDesk

This project was NOT easy.

⚠️ Architecture Complexity

This is not a simple todo app.

The moment you start handling:

sponsors
approvals
finance
partnerships
workflows

…system design complexity increases massively.

I had to rethink architecture multiple times.

⚠️ Tauri Linux Build Issues

One of the biggest pain points.

Especially AppImage packaging and Linux deployment tooling.

There were multiple dependency and bundling issues while making production builds work correctly across distributions.

⚠️ State Management

Managing large operational dashboards requires scalable frontend architecture.

I experimented with different approaches to keep:

API handling clean
auth stable
state predictable
caching efficient

⚠️ Production-Grade Backend Design

Building APIs is easy.

Building maintainable systems is hard.

A lot of time went into:

modular backend structure
auth handling
scalable API design
operational workflows
error handling
future extensibility

What I Learned

This project taught me more than tutorials ever could.

Real engineering starts when complexity appears.

Not when everything works.

But when:

architecture breaks
workflows scale
systems become interconnected
operations become difficult

That’s where actual software engineering begins.

Open Source & Future Goals

CommDesk is just getting started.

Future plans include:

Real-time collaboration
Multi-community support
Advanced analytics
AI-powered operational insights
Automation workflows
Better event orchestration
Team collaboration systems
Advanced permission systems

Screens & System Modules

Current operational modules include:

Sponsorship Operations Dashboard
Sponsor Details Management
Sponsorship Lifecycle & Renewals
Partnership Request Queue
Event Fund Dispatch & Management
Event Fund Approval Detail
New Fund Request Forms
Community Operations Dashboard
Team Management
Event Coordination Systems

Why I Open-Sourced It

Because communities deserve better tooling.

Most community organizers spend more time managing operations than actually building communities.

CommDesk aims to solve that.

Final Thoughts

CommDesk started as a simple idea.

But slowly evolved into a large operational platform designed for real-world community management.

Still a long way to go.

Still improving architecture.

Still refining workflows.

Still learning.

But that’s what building real software is about.

If you like the project:

⭐ Star the repositories
🍴 Contribute
🛠️ Open issues
🚀 Share feedback

🔐 Cyber Security — Zero to Monster Notes (MCU BCA 4th Sem)

Abhishek Gupta — Thu, 14 May 2026 08:04:24 +0000

Beginner → Exam Ready → Viva Ready → Interview Ready 🚀

Based on:

BCU Syllabus
2023 PYQ
2024 PYQ
2025 PYQ

📚 About This Notes

These notes are made for students who:

did not study whole semester 😭
want easy English
want exam-focused notes
want quick revision
want important questions only
want pass + score good marks

🔖 Tags

Tag	Meaning
⭐⭐⭐⭐	Very Important
🔥	High Chance in Exam
📝	Theory Question
❓	Frequently Asked
⚠️	Viva Question
💡	Easy Trick

📅 5-Day Plan

Day	Topics
Day 1	Unit 1
Day 2	Unit 2
Day 3	Unit 3
Day 4	Unit 4
Day 5	Unit 5 + Revision

🧠 UNIT 1 — INFORMATION SECURITY

✅ What is Information Security? 🔥⭐⭐⭐⭐

Easy Definition

Information Security means:

Keeping data and information safe from:

hackers

theft

damage

misuse

💡 Simple Meaning

Information Security protects:

passwords
bank details
personal data
files

🌍 Real Life Examples

Example	Security
ATM PIN	Protected
WhatsApp Chat	Encrypted
Gmail Password	Secured

✅ Importance of Information Security 🔥⭐⭐⭐⭐

Why Important?

Today everything is online:

banking
shopping
education
social media

Without security:

money can be stolen
accounts can be hacked
privacy can be broken

✅ Components of Information Security 🔥⭐⭐⭐⭐

1. Confidentiality

Only authorized users can access data.

Example

Only you should know your password.

2. Integrity

Data should remain correct.

Example

Marks in database should not change illegally.

3. Availability

Data should be available when needed.

Example

Bank server should work anytime.

💡 Easy Trick

CIA

C → Confidentiality
I → Integrity
A → Availability

✅ Threats to Information System 🔥⭐⭐⭐⭐

Threat Meaning

Anything that can damage system or data.

Types of Threats

1. Internal Threat

Threat from inside organization.

Examples

careless employee
weak password
data misuse

2. External Threat

Threat from outside organization.

Examples

hackers
viruses
cyber attacks

Difference Between Internal and External Threat

Internal	External
Inside attack	Outside attack
Employee misuse	Hacker attack

✅ Vulnerability 🔥⭐⭐⭐⭐

Meaning

Weak point in security.

Example

Weak password.

💡 Easy Example

Weak Password = Vulnerability
Hacker = Threat

✅ Malware 🔥⭐⭐⭐⭐

Meaning

Malware = Malicious Software

Harmful software that damages system.

Types of Malware

1. Virus ⭐⭐⭐⭐

Attaches to files and spreads.

Effects

corrupt files
slow computer

2. Worm ⭐⭐⭐⭐

Spreads automatically through network.

3. Trojan Horse ⭐⭐⭐⭐

Looks useful but harmful internally.

Example

Fake software.

4. Spyware ⭐⭐⭐⭐

Steals user information secretly.

5. Adware ⭐⭐⭐

Shows unwanted ads.

6. Ransomware 🔥⭐⭐⭐⭐

Locks files and asks money.

7. Rootkit ⭐⭐⭐

Hides malware activities.

8. Zombie ⭐⭐⭐

Computer controlled remotely by hacker.

Difference Between Virus and Worm ⭐⭐⭐⭐

Virus	Worm
Needs user action	Spreads automatically
Attached to files	Through network

✅ Desktop Security 🔥⭐⭐⭐⭐

Meaning

Protecting personal computer from attacks.

Methods of Desktop Security

Antivirus
Strong password
Firewall
Updates
Backup

🧠 UNIT 2 — APPLICATION SECURITY & CRYPTOGRAPHY

✅ Application Security 🔥⭐⭐⭐⭐

Meaning

Protecting software applications from attacks.

Examples

banking app
payment app
login system

✅ Database Security 🔥⭐⭐⭐⭐

Meaning

Protecting database from:

hacking
theft
unauthorized access

Importance

protects user data
keeps information private
prevents data loss

Database Security Methods

password protection
backup
encryption
access control

✅ Email Security ⭐⭐⭐⭐

Protecting email from:

spam
phishing
malware

Email Security Methods

strong password
spam filter
antivirus
encryption

✅ Internet Security ⭐⭐⭐⭐

Meaning

Protection while using internet.

Internet Threats

fake websites
malware
phishing
hacking

Internet Protection

HTTPS websites
firewall
antivirus
VPN

✅ Cryptography 🔥⭐⭐⭐⭐

Meaning

Converting readable data into secret code.

Example

HELLO → XJ29LQ

Types of Cryptography

1. Symmetric Key Cryptography ⭐⭐⭐⭐

Uses one key.

Same key used for:
- lock
- unlock

Advantages

✅ Fast

✅ Easy

Disadvantages

❌ Key sharing problem

2. Asymmetric Key Cryptography ⭐⭐⭐⭐

Uses two keys:

Public Key
Private Key

Advantages

✅ More secure

Disadvantages

❌ Slower

Difference Between Symmetric and Asymmetric

Symmetric	Asymmetric
One key	Two keys
Faster	Slower
Less secure	More secure

✅ Firewall 🔥⭐⭐⭐⭐

Meaning

Firewall controls network traffic.

💡 Easy Meaning

Firewall works like:

Security Guard of Network

Types of Firewall

Hardware Firewall
Software Firewall
Proxy Firewall

Benefits of Firewall

✅ Blocks hackers

✅ Protects network

✅ Monitors traffic

✅ VPN ⭐⭐⭐⭐

Meaning

VPN creates secure internet connection.

Uses

secure browsing
privacy protection
hides IP address

✅ Antivirus Software 🔥⭐⭐⭐⭐

Meaning

Software that detects and removes malware.

Role of Antivirus

virus detection
malware removal
file protection
system scanning

Popular Antivirus

Avast
Norton
Quick Heal
Windows Defender

🧠 UNIT 3 — CYBERSPACE & NETWORK SECURITY

✅ Cyberspace ⭐⭐⭐⭐

Meaning

Digital world created using internet.

Examples

websites
apps
social media
cloud services

✅ Cloud Computing Security 🔥⭐⭐⭐⭐

Meaning

Protecting cloud data and services.

Risks

data theft
data loss
hacking

Protection

encryption
backup
authentication

✅ Social Media Security 🔥⭐⭐⭐⭐

Risks

fake profiles
cyber bullying
identity theft
data leak

Protection Methods

strong password
privacy settings
avoid unknown links
2FA

✅ Password Security 🔥⭐⭐⭐⭐

Strong Password Rules

✅ Use:

letters
numbers
symbols

❌ Avoid:

name
birth date
mobile number

Example

Abhi@2026#Secure

✅ Wireless Network Security ⭐⭐⭐⭐

Threats

WiFi hacking
data interception

Protection

strong WiFi password
WPA2/WPA3
hide SSID

🧠 UNIT 4 — CYBERCRIME & DIGITAL SIGNATURE

✅ Cybercrime 🔥⭐⭐⭐⭐

Meaning

Illegal activities using internet or computer.

Examples

hacking
phishing
online fraud
identity theft

Types of Cybercrime

hacking
phishing
cyber stalking
online fraud

✅ Phishing 🔥⭐⭐⭐⭐

Meaning

Fake websites or emails used to steal information.

Example

Fake bank login page.

Cybercrime Prevention

strong passwords
antivirus
avoid suspicious links
software updates

✅ E-Commerce Security Threats ⭐⭐⭐⭐

payment fraud
fake websites
data theft
card theft

Electronic Payment System

Examples:

UPI
Credit Card
Net Banking
Paytm

✅ Digital Signature 🔥⭐⭐⭐⭐

Meaning

Electronic signature used for authentication.

Uses

secure documents
verify identity
online transactions

Digital Signature Process

Message
   ↓
Hash Function
   ↓
Private Key
   ↓
Digital Signature

Advantages

✅ Security

✅ Authentication

✅ Data Protection

🧠 UNIT 5 — CYBER LAW & IT ACT

✅ Cyber Law 🔥⭐⭐⭐⭐

Meaning

Laws related to:

internet
cybercrime
digital activities

✅ IT Act 2000 🔥⭐⭐⭐⭐

Meaning

Indian law for:

cybercrime control
digital signatures
electronic records

Objectives of IT Act 2000

prevent cybercrime
legal support for e-documents
secure online business

How IT Act 2000 Protects India

punishes hackers
controls online fraud
protects electronic records

✅ Intellectual Property Rights (IPR) 🔥⭐⭐⭐⭐

Meaning

Rights protecting creations of human mind.

Types of IPR

Copyright
Patent
Trademark
Design

✅ Copyright

Protects:

books
software
movies
music

✅ Patent

Protects inventions.

✅ Trademark

Protects:

logos
symbols
brand names

Examples

Nike Logo
Apple Logo

🎤 INTERVIEW + VIVA QUESTIONS

✅ What is Cyber Security? ⭐⭐⭐⭐

Cyber security means protecting:

systems
networks
data

from cyber attacks.

✅ Difference Between Threat and Vulnerability ⭐⭐⭐⭐

Threat	Vulnerability
Danger	Weakness
Hacker attack	Weak password

✅ Difference Between Firewall and Antivirus ⭐⭐⭐⭐

Firewall	Antivirus
Controls network traffic	Removes malware
Network protection	File protection

🧠 QUICK REVISION

Information Security

Protecting data and information.

Malware

Harmful software.

Firewall

Security guard of network.

Antivirus

Software that removes malware.

Cryptography

Converting data into secret code.

Cybercrime

Crime using internet.

Digital Signature

Electronic signature.

IT Act 2000

Indian cyber law.

🔥 MOST IMPORTANT QUESTIONS

Information Security ⭐⭐⭐⭐
CIA Triad ⭐⭐⭐⭐
Malware Types ⭐⭐⭐⭐
Firewall ⭐⭐⭐⭐
Antivirus ⭐⭐⭐⭐
Database Security ⭐⭐⭐⭐
Cryptography ⭐⭐⭐⭐
Symmetric vs Asymmetric ⭐⭐⭐⭐
Cybercrime ⭐⭐⭐⭐
Phishing ⭐⭐⭐⭐
Digital Signature ⭐⭐⭐⭐
IT Act 2000 ⭐⭐⭐⭐
IPR ⭐⭐⭐⭐
Cloud Security ⭐⭐⭐⭐
Desktop Security ⭐⭐⭐⭐

🎯 HOW TO WRITE ANSWERS IN EXAM

For 2 Marks

Write:

definition
2 points

For 5 Marks

Write:

definition
explanation
examples
advantages

For 10 Marks

Write:

Introduction
Definition
Diagram
Explanation
Advantages
Disadvantages
Conclusion

💡 SCORING TIPS

✅ Learn definitions

✅ Practice diagrams

✅ Learn differences

✅ Revise malware types

✅ Focus on IT Act 2000

✅ Learn CIA properly

🚀 FINAL MESSAGE

You do NOT need:
❌ 6 months study

❌ difficult books

❌ complex theory

You only need:
✅ smart revision

✅ important topics

✅ diagrams

✅ confidence

👉 Read ⭐⭐⭐⭐ topics 2–3 times

👉 Practice important differences

👉 Revise before sleep

👉 Go confidently to exam

Smart study beats long study 🚀

DEV Community: Abhishek Gupta

Linked List Mistakes Every Beginner Makes (Including Me)

First, What Actually Is a Linked List?

Mistake 1: Thinking a Variable Creates a New Node

Important Lesson

Mistake 2: Not Understanding the Difference Between Moving a Pointer and Changing a Link

Moving a variable

Changing .next

Mistake 3: Accessing .next Without Checking for null

Mistake 4: Forgetting to Save the Next Node

Simple Rule

Mistake 5: Forgetting to Update Pointers

Mistake 6: Updating Pointers in the Wrong Order

Before swapping

Connect first to remaining

Connect second to first

Connect prev to second

Mistake 7: Not Using a Dummy Node

When should beginners consider a Dummy Node?

Mistake 8: Creating Too Many Variables

Mistake 9: Losing Part of the Linked List

Mistake 10: Not Dry Running the Code

Mistake 11: Forgetting How the Loop Moves Forward

Mistake 12: Forgetting Edge Cases

Empty List

One Node

Two Nodes

Odd Number of Nodes

Even Number of Nodes

Mistake 13: Accidentally Creating an Infinite Loop

Mistake 14: Trying to Solve Everything in One Go

The Biggest Lesson I Learned

My New Mental Model for Linked Lists

A Simple Checklist for Linked List Problems

1. What does each pointer represent?

2. Can the head change?

3. Can the list be empty?

4. Can there be only one node?

5. Will changing .next disconnect part of the list?

6. How will my pointers move forward?

7. What is my stopping condition?

8. Did I dry run small examples?

Final Thoughts

Related Links

javascript #leetcode #dsa #datastructures #algorithms #linkedlist #programming #codingjourney #learninginpublic #beginners #100daysofcode

🏆 Software Engineering Roadmap (0 Monster)

Complete Learning Sequence for SDE | Backend | Full Stack | System Design | FAANG+ | Product Companies

🟢 Phase 0 — Foundation

1. Computer Fundamentals ⭐⭐⭐⭐⭐

2. Programming Fundamentals ⭐⭐⭐⭐⭐

3. Object-Oriented Programming ⭐⭐⭐⭐⭐

4. Git & GitHub ⭐⭐⭐⭐⭐

5. Linux ⭐⭐⭐⭐⭐

🔵 Phase 1 — Problem Solving

6. Mathematics ⭐⭐⭐⭐

7. Aptitude ⭐⭐⭐⭐

Quantitative Aptitude

8. Logical Reasoning ⭐⭐⭐⭐

9. Verbal Ability ⭐⭐⭐⭐

🟣 Phase 2 — Data Structures & Algorithms ⭐⭐⭐⭐⭐

Data Structures

Algorithms

🟠 Phase 3 — Core Computer Science

10. Operating Systems ⭐⭐⭐⭐⭐

11. Computer Networks ⭐⭐⭐⭐⭐

12. Database Management Systems ⭐⭐⭐⭐⭐

SQL

NoSQL

Concepts

🔴 Phase 4 — Software Engineering

13. Software Engineering Principles ⭐⭐⭐⭐⭐

14. Design Patterns ⭐⭐⭐⭐

🟡 Phase 5 — Backend Development ⭐⭐⭐⭐⭐

🟢 Phase 6 — Frontend (Optional for Backend) ⭐⭐⭐⭐

🔵 Phase 7 — Cloud & DevOps ⭐⭐⭐⭐

Docker

Kubernetes

AWS

CI/CD

🟣 Phase 8 — System Design ⭐⭐⭐⭐⭐

Changing `.next`

Mistake 3: Accessing `.next` Without Checking for `null`

Connect `first` to remaining

Connect `second` to `first`

Connect `prev` to `second`

5. Will changing `.next` disconnect part of the list?