DEV Community: Abhishek Gupta

Gemini & Gemini CLI — Beginner Learning Notes

Abhishek Gupta — Thu, 15 Oct 2026 16:59:39 +0000

Chapter 1: Introduction to Gemini CLI

1. What is Artificial Intelligence (AI)?

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

Examples include:

Understanding questions.
Generating text and code.
Recognizing patterns.
Explaining concepts.
Helping solve problems.

2. What is Gemini?

Gemini is a family of AI models developed by Google.

An AI model processes input and generates a response based on its training and the information available to it.

Example:

You ask:

Explain JavaScript functions in simple English.

Gemini can explain functions, provide examples, and help you understand how they work.

3. What is Gemini CLI?

Gemini CLI is an open-source AI assistant that lets developers interact with Gemini through a command-line interface.

CLI stands for Command-Line Interface.

Instead of using only a web-based chat interface, you can work with Gemini from your terminal and use its available tools to interact with your development project.

For example, you can ask Gemini CLI to:

Explain your project structure.
Create or edit source files.
Find bugs in your code.
Help write tests.
Run commands when permitted.
Generate documentation.
Help you understand an unfamiliar codebase.

Example prompt:

Explain the folder structure of this project.
Identify the main entry point.
Do not modify any files.

Gemini CLI can inspect relevant project files using its available tools and permissions.

4. How is Gemini CLI different from a normal AI chatbot?

A normal chatbot is primarily designed for conversations. Gemini CLI is designed to bring AI assistance into a terminal-based development workflow.

Gemini chat	Gemini CLI
Usually accessed through a chat interface	Accessed through a terminal
Explains concepts and generates code	Can work with project files using tools
You often copy code into your editor	It can edit files when authorized
Works with information you provide	Can inspect relevant local project information
Mainly conversation-oriented	Supports tool-assisted development tasks

Important: Gemini is the AI model family. Gemini CLI is the tool used to interact with Gemini from the command line.

5. Why do developers use Gemini CLI?

Imagine you have an existing React project with many files. You want to understand how the application works.

Without an AI coding assistant, you may need to inspect every relevant file manually.

With Gemini CLI, you can ask:

Study this project and explain:
1. The main application entry point.
2. The components folder.
3. How routing works.
4. How API requests are handled.
5. Where the application state is managed.

Explain everything in beginner-friendly language.
Do not modify any files.

This can help you understand the project faster. However, you should verify its explanations against the actual code.

6. What are the limitations of Gemini CLI?

Gemini CLI is helpful, but it is not perfect.

It can generate incorrect code.
It can misunderstand project requirements.
It can make unwanted changes if instructions are unclear.
It may not have access to every file or tool.
It may require authentication and an internet connection.
Its available features depend on the installed version, account, configuration, and permissions.

Rule: Never accept AI-generated code blindly. Review it, test it, and understand the changes.

Quick revision

AI: Technology that enables computers to perform intelligent tasks.
Gemini: Google's family of AI models.
Gemini CLI: A terminal-based AI assistant.
CLI: Command-Line Interface.
Prompt: An instruction or question given to an AI.
Codebase: The collection of source code and related files in a project.

Interview questions

Q1. What is Gemini CLI?

Gemini CLI is an open-source, terminal-based AI assistant that allows developers to interact with Gemini and perform coding tasks using available tools.

Q2. What does CLI stand for?

CLI stands for Command-Line Interface. It allows users to interact with a computer or program by entering text commands.

Q3. How is Gemini CLI useful to developers?

It can help developers understand codebases, generate and edit files, debug problems, write tests, and create documentation.

Q4. Does Gemini CLI always generate correct code?

No. It can make mistakes, so developers should review the generated code and run appropriate tests.

Chapter 2: Terminal and Command-Line Basics

1. What is a terminal?

A terminal is an application that lets you interact with your computer by typing commands.

Examples:

Windows: PowerShell or Windows Terminal.
Linux: Terminal.
macOS: Terminal.

2. What is a shell?

A shell is a program that interprets commands and executes them or passes them to the appropriate system tools.

For example, Bash and Zsh are common Linux/macOS shells. PowerShell is commonly used on Windows.

Remember the difference:

Terminal: The application where you enter commands.
Shell: The program that interprets those commands.

3. Essential terminal commands

Command	Purpose
`pwd`	Show the current directory on Linux/macOS
`ls`	List files on Linux/macOS
`dir`	List files in PowerShell
`cd folder-name`	Enter a directory
`mkdir project-name`	Create a directory
`node --version`	Check the Node.js version
`npm --version`	Check the npm version

Some commands differ between operating systems and shells.

4. Working with a project directory

Suppose you want to create a folder for learning Gemini CLI.

mkdir learning-project
cd learning-project

What happens?

mkdir learning-project creates a directory.
cd learning-project moves into that directory.

Start Gemini CLI from the project directory:

gemini

This helps the tool work with the intended project context.

5. Why does the current directory matter?

The current directory is the location in which your shell is currently working.

When you start Gemini CLI from a project directory, its access to project files and instruction files depends on the working directory, configuration, permissions, and instruction-loading rules.

For example, starting it inside your React project is more useful when you want help with that React project than starting it from an unrelated directory.

Best practice: Check your current directory before asking an AI assistant to modify files.

Practice task

Open your terminal.
Create a folder named gemini-practice.
Enter that folder.
Check your current location.
Start Gemini CLI if it is installed.

Interview questions

Q1. What is a terminal?

A terminal is an application that provides a text-based interface for interacting with a computer.

Q2. What is a shell?

A shell interprets commands and executes them or invokes the required programs.

Q3. Why should you start Gemini CLI from the project directory?

It helps Gemini CLI work in the intended project context and locate relevant files according to its configuration and permissions.

Chapter 3: Installing and Starting Gemini CLI

1. What is Node.js?

Node.js is a JavaScript runtime that allows JavaScript to run outside a web browser.

It is required for the npm-based Gemini CLI installation method described in these notes.

Official website: https://nodejs.org/

2. What is npm?

npm is a package manager used to install and manage JavaScript packages.

A package manager helps developers install software and its dependencies.

3. Check your installation

Run these commands:

node --version
npm --version

If both commands return version numbers, Node.js and npm are available in your terminal.

If either command is unavailable, check your installation and PATH configuration.

4. Install Gemini CLI using npm

Run:

npm install -g @google/gemini-cli

Understand the command:

npm: Runs the package manager.
install: Installs a package.
-g: Requests a global installation.
@google/gemini-cli: Identifies the package.

Verify the installation:

gemini --version

Start the tool:

gemini

Follow the authentication instructions displayed on your screen.

5. What is global installation?

A global installation makes a package's command available from different directories, subject to your system's PATH and installation configuration.

This is useful for command-line tools that you want to run across multiple projects.

6. Linux installation using Snap

Snap is a package system available on supported Linux distributions.

Check Snap:

snap version

Install the package:

sudo snap install gemini-cli

Verify and start:

gemini --version
gemini

Important: This Snap package is community-maintained, not an official Google-published package. Snap may also restrict access to some files.

For beginners, the npm method is a straightforward option when Node.js and npm are configured correctly.

7. Common installation problems

Problem	What to check
`node` not found	Install Node.js and check PATH
`npm` not found	Check Node.js installation
`gemini` not found	Check installation output and executable path
Permission denied	Check npm configuration and file permissions
Login fails	Check network and supported authentication options
Project files are inaccessible	Check the current directory and filesystem permissions

Avoid immediately using sudo to solve npm global-installation errors. Fix the underlying permission or configuration problem instead.

8. Authentication

Authentication establishes that you are authorized to use a service.

On first launch, Gemini CLI may offer authentication options. Follow the current instructions displayed by your installed version.

Available options can depend on your account, location, and configuration.

Official documentation: https://geminicli.com/docs/

Practice task

Install Gemini CLI and confirm that:

Node.js works.
npm works.
gemini --version returns a version.
gemini starts successfully.
You can complete a supported authentication flow.

Chapter 4: Understanding Prompts

1. What is a prompt?

A prompt is the instruction or question you give an AI assistant.

The quality of your prompt affects how clearly the assistant understands your requirements.

2. Weak prompt vs. good prompt

Weak prompt:

Make a calculator website.

The instruction does not explain what kind of website is needed, which technologies to use, or what features to include.

Better prompt:

Build a complete, responsive calculator web application.

Requirements:

1. Technologies
- Use HTML, CSS, and vanilla JavaScript.
- Do not use external libraries or frameworks.
- Separate the application into index.html, style.css, and script.js.

2. Calculator functionality
- Support addition, subtraction, multiplication, and division.
- Support decimal numbers and negative numbers.
- Include Clear (C), Delete (⌫), and Equals (=) buttons.
- Follow standard arithmetic operator precedence.
- Support keyboard input.
- Prevent division by zero and display a helpful error message.
- Handle invalid expressions safely.

3. UI and design
- Create a clean, modern, professional calculator interface.
- Use a dark theme with subtle blue accents.
- Make buttons easy to identify and use.
- Display the current expression and result clearly.
- Support desktop, tablet, and mobile screens.
- Include hover, focus, and pressed states.

4. Code quality
- Use readable, maintainable JavaScript.
- Separate UI updates from calculation logic where practical.
- Do not use eval() to calculate expressions.
- Avoid unnecessary code and dependencies.
- Include helpful comments for important logic.

5. Testing
- Test addition, subtraction, multiplication, and division.
- Test decimals, negative numbers, and operator precedence.
- Test division by zero, invalid input, Clear, and Delete.
- Fix any issues found during testing.

6. Completion report
- List the files created or modified.
- Explain how to run the application.
- Summarize the tests performed and their actual results.
- Report any unfinished features or known limitations.

First inspect the existing project, if one exists. Then implement the calculator, run the available checks, and summarize the completed work. Do not claim a test passed unless you actually ran it.

The second prompt gives the AI clearer requirements.

3. A simple prompt-writing formula

Use these four elements:

Goal + Context + Requirements + Restrictions

Goal: What do you want to accomplish?
Context: What project or files are involved?
Requirements: What must the result include?
Restrictions: What must not be changed?

Example:

Goal:
Fix the login form validation.

Context:
This is an existing React application.

Requirements:
Validate the email and password fields.
Display useful error messages.
Keep the current design.

Restrictions:
Do not change the authentication API.
Do not modify unrelated files.

4. Prompting tips

Explain your goal clearly.
Mention the technology stack.
Provide relevant error messages.
Describe the expected behavior.
Specify what should not change.
Ask for explanations when learning.
Request tests when appropriate.
Review changes before accepting them.

Interview questions

Q1. What is prompt engineering?

Prompt engineering is the practice of writing and refining instructions so that an AI system can better understand the task and produce useful results.

Q2. What makes a prompt effective?

A useful prompt clearly states the goal, provides relevant context, lists requirements, and specifies important restrictions.

Q3. Can a detailed prompt guarantee a correct result?

No. A detailed prompt reduces ambiguity, but the result must still be checked and tested.

Chapter 5: Using Gemini CLI with an Existing Project

1. First understand the project

Do not immediately ask the AI to rewrite your entire application.

Start by understanding the existing codebase.

Analyze this project.

Explain:
1. The folder structure.
2. The main entry point.
3. The technologies used.
4. How the application starts.
5. How the frontend communicates with the backend.

Use simple English.
Do not modify any files.

2. Generate a new feature

After understanding the project, ask for a specific task.

Add a search field to the existing user list.

Requirements:
- Search users by name.
- Update results as the user types.
- Follow the existing coding style.
- Keep the current layout.
- Do not modify unrelated features.
- Explain the changes.

3. Debug an error

When something breaks, ask the AI to investigate the cause before changing code.

Investigate this error.

First:
1. Identify the likely cause.
2. Explain why it happens.
3. Suggest the smallest suitable fix.

Then apply the fix only if appropriate.
Run the relevant tests if available.
Do not change unrelated files.

4. Review changes

After the assistant modifies code, check:

Which files changed?
Does the code solve the original problem?
Were unrelated files modified?
Are there new errors?
Do existing tests still pass?
Are there security or performance concerns?

Important: You remain responsible for the code, even when an AI assistant writes it.

Chapter 6: Understanding GEMINI.md

1. What is GEMINI.md?

GEMINI.md is a Markdown file that provides project-specific instructions and context to Gemini CLI.

It can help the assistant follow the project's conventions across multiple tasks.

2. Example

# Project Instructions

## Technology
- Use JavaScript for frontend code.
- Follow the existing framework and project structure.

## Coding Style
- Write small, readable functions.
- Use meaningful variable names.
- Avoid unnecessary duplication.

## Project Rules
- Do not modify unrelated files.
- Explain important changes.
- Run relevant tests when possible.

3. Why is it useful?

Without project instructions, you may need to repeat the same requirements in multiple prompts.

A suitable GEMINI.md file provides reusable guidance.

However, it does not guarantee perfect compliance. You should still review the generated code.

Interview question

What is the purpose of GEMINI.md?

It provides reusable project instructions and context that help Gemini CLI understand the project's conventions and requirements.

Official documentation: https://geminicli.com/docs/

Chapter 7: Commands and Tools

1. Gemini CLI slash commands

Common commands include:

Command	Purpose
`/help`	Show help information
`/tools`	Inspect available tools
`/clear`	Clear conversation context
`/quit`	Exit, where supported

The available commands may vary between versions. Use /help to check the commands supported by your installation.

2. Terminal commands vs. slash commands

These are different types of commands.

Terminal command:

npm --version

This is executed by your shell.

Gemini CLI slash command:

/help

This is entered inside the Gemini CLI interface.

Do not assume that every terminal command is a Gemini CLI slash command.

3. What are tools?

Tools allow an AI assistant to perform actions beyond generating text.

Depending on the configuration, available tools may allow Gemini CLI to inspect files, edit code, run commands, or access other resources.

Tool access may be restricted by permissions and configuration.

4. Why are permissions important?

Some actions only read information. Others can change files or execute commands.

Before approving an unfamiliar or destructive action:

Understand what it will do.
Check which files or resources it affects.
Confirm that the action is appropriate.
Keep a backup or Git commit when necessary.

Chapter 8: Safety and Best Practices

AI-assisted development introduces risks if generated commands or code are trusted without review.

Important rules

Never share passwords, API keys, or access tokens in prompts.
Review file changes before accepting them.
Understand commands before allowing them to run.
Avoid approving destructive operations without checking their impact.
Keep important work backed up or committed to Git.
Run tests after making changes.
Inspect generated code for security issues.
Verify third-party packages before installing them.

Interview question

Why should developers review AI-generated code?

Because AI can produce incorrect, insecure, inefficient, or irrelevant code. Reviewing and testing the result helps ensure it meets the requirements.

Chapter 9: Interview Revision

Important questions and answers

1. What is Gemini CLI?

An open-source terminal-based AI assistant for working with Gemini and performing development tasks using available tools.

2. What does CLI stand for?

Command-Line Interface.

3. What is the difference between Gemini and Gemini CLI?

Gemini is Google's family of AI models, while Gemini CLI is a terminal-based tool for interacting with Gemini.

4. What is a prompt?

An instruction or question given to an AI assistant.

5. What is prompt engineering?

The practice of designing clear instructions to help an AI understand and perform a task.

6. What is Node.js?

A JavaScript runtime that allows JavaScript to execute outside a web browser.

7. What is npm?

A package manager used to install and manage JavaScript packages.

8. What does npm install -g mean?

It installs a package globally, making its command available from different directories when the environment is configured correctly.

9. What is authentication?

The process of verifying identity or establishing authorized access to a service.

10. What is GEMINI.md?

A Markdown file containing project-specific instructions and context for Gemini CLI.

11. Why should Gemini CLI be started in the project directory?

To work in the intended project context and make relevant files available according to the tool's permissions and configuration.

12. Does Gemini CLI replace a developer?

No. It assists with development, but developers must understand requirements, review code, test results, and make technical decisions.

13. What should you do before allowing the AI to edit an existing project?

Understand the task, define restrictions, review the planned changes, and protect important work with version control or backups.

14. How can you improve an incorrect AI-generated answer?

Provide clearer context, specify the expected behavior, share relevant errors, and ask for a focused correction. Then verify the result.

Chapter 10: Practical Learning Checklist

Use this checklist to measure your progress.

[ ] Explain Gemini and Gemini CLI in your own words.
[ ] Explain the difference between a terminal and a shell.
[ ] Install Node.js and npm.
[ ] Install and launch Gemini CLI.
[ ] Complete a supported authentication method.
[ ] Ask Gemini CLI to explain a project without editing files.
[ ] Write a clear prompt using goal, context, requirements, and restrictions.
[ ] Create or modify a small feature.
[ ] Ask Gemini CLI to investigate and fix a bug.
[ ] Understand the purpose of GEMINI.md.
[ ] Inspect file changes and run relevant tests.
[ ] Explain important concepts without looking at the notes.

Final Revision

Remember these core ideas:

Gemini is the AI model family.
Gemini CLI brings AI assistance into the terminal.
Prompts communicate your requirements.
Project context helps the AI understand what it needs to do.
GEMINI.md provides reusable project instructions.
Tools enable actions such as inspecting files or running commands.
Permissions control which actions are allowed.
Testing and code review remain essential.

Learning strategy: Understand one concept, try one practical example, and then answer its interview question without looking at the notes.

DevFest 2026 — Gemini CLI Game Challenges

Abhishek Gupta — Thu, 15 Oct 2026 16:41:17 +0000

Welcome to the Gemini CLI Game Challenges at DevFest Ranchi 2026, organized by Google Developer Groups (GDG) Ranchi!

These challenges are designed to help participants explore AI-assisted development, solve practical problems, build applications, and experience how Gemini CLI can support real-world software development.

Whether you enjoy designing user interfaces, building AI-powered applications, or testing your knowledge of Gemini CLI, there is a challenge for you.

1. Challenge Overview

Challenge	Time Limit	Maximum Score
UI Makeover Challenge	5–10 minutes	100 points
Build with Gemini — AI Chatbot Challenge	30–35 minutes	100 points
AI Faster Finger First Challenge	20 minutes	10 points

All challenges are conducted at the DevFest Ranchi 2026 booth.

Important: These are on-the-spot competitions. Participants must complete their assigned challenge and demonstrate their work to the booth organizers. There is no Google Form submission for the UI Makeover or AI Chatbot challenges.

2. How to Participate

Visit the Gemini CLI Game Challenges booth at DevFest Ranchi 2026.
Meet the organizers or booth volunteers to learn about the available challenges.
Get your assigned challenge, instructions, and starter project, where applicable.
Read the requirements carefully before beginning.
Complete the challenge independently using Gemini CLI and the provided resources.
Demonstrate your completed work directly to the booth organizers within the allotted time.
The organizers will evaluate your work according to the published scoring criteria.
Participants with the highest scores and best completion times will be considered for exclusive DevFest goodies.

First Come, First Serve: Participants should be ready to begin when their turn is announced. For challenges with equal scores, the participant who successfully completes and demonstrates the challenge first will receive priority.

3. General Rules

Individual participation: Each participant must complete their assigned challenge independently unless the organizers announce otherwise.
Use Gemini CLI: Gemini CLI is the primary AI development tool for these challenges.
Follow the starter project: When a starter repository is provided, use it as the starting point and follow its instructions.
Understand before building: Read the challenge instructions and requirements before making changes.
Original work: Do not copy another participant's solution or prompt.
Protect secrets: Never commit API keys, passwords, tokens, or other sensitive information to a public repository.
Test your work: Verify that the application runs and its required features work before demonstrating it.
Follow time limits: Complete and demonstrate your work within the allocated time.
Ask for assistance: If you face an environment, setup, or tool issue, contact the organizers through the support channel or at the booth.
On-the-spot evaluation: Your work must be demonstrated to the booth organizers for evaluation. Merely completing the code without showing the working result may not qualify for full marks.

4. Winner Selection and Exclusive Goodies

The Gemini CLI Game Challenges are designed to reward practical skills, creativity, problem-solving, and effective use of AI development tools.

Participants who successfully complete their assigned challenge will be evaluated by the booth organizers.

How winners are selected

Highest score wins: Participants are ranked according to their total evaluation score.
First Come, First Serve: If multiple participants achieve the same highest score, the participant who completes and demonstrates the challenge first receives priority.
On-the-spot judging: Organizers will evaluate the participant's actual work, functionality, originality, and understanding of the solution.
Exclusive goodies: Participants who achieve the highest scores and satisfy the challenge requirements will have a chance to win exclusive DevFest goodies.

For the AI Faster Finger First Challenge, the first participant to submit all answers with the highest score wins.

Please note: Participation does not guarantee a prize. Goodies are awarded based on the organizers' evaluation and the available prize allocation.

Challenge 1: UI Makeover Challenge

Time limit: 5–10 minutes

Maximum score: 100 points

Objective

Improve an existing website's user interface using Gemini CLI.

You will start with an existing project and redesign its interface to make it more attractive, readable, usable, and responsive while preserving its important functionality.

This challenge focuses on how effectively you can communicate design requirements to an AI coding assistant and turn an existing interface into a better user experience.

What You Need to Do

Open the starter repository and inspect the existing project.
Run the application and understand its current interface.
Identify areas that need improvement, such as layout, spacing, typography, colors, navigation, or responsiveness.
Use Gemini CLI to implement the improvements.
Run the application and check that the redesign works.
Demonstrate your updated interface to the organizers.

Design Expectations

Your redesigned interface should aim for:

Visual quality: A clean, consistent, professional design.
Layout and spacing: Proper alignment, spacing, and content hierarchy.
Typography: Readable font sizes, appropriate font weights, and clear headings.
Color consistency: A balanced color palette with sufficient contrast.
Responsiveness: A layout that works on mobile, tablet, and desktop screens.
Functionality: Existing important features and interactions should continue to work.
User experience: Navigation and content should be easy to understand.
Accessibility: Readable text, meaningful labels, and appropriate contrast.
Creativity: Thoughtful improvements rather than unnecessary visual decoration.

Starter Project

GitHub repository: https://github.com/abhishek-nexgen-dev/gdg-ranchi-ui-challenge
Live demo: https://gdg-ranchi-ui-challenge.vercel.app/

Example Gemini CLI Prompt

Adapt this prompt to the actual interface and the time available.

Inspect the existing project and understand its current UI,
components, routes, and functionality.

Improve the interface to make it clean, modern, professional,
and responsive. Improve layout, spacing, typography, colors,
visual hierarchy, and navigation where needed.

Make sure the application works well on mobile, tablet, and
desktop screens. Preserve existing functionality and avoid
unnecessary dependencies or unrelated features.

Follow the project's existing technology stack and coding
conventions. Implement the changes in the codebase, then run
the application and check for obvious errors or broken
interactions.

Evaluation Criteria

Criterion	Points
Design Quality	35
Responsiveness	10
Functionality	20
Creativity and Originality	15
User Experience and Accessibility	20
Total	100

On-the-Spot Judging

After completing the redesign, participants must demonstrate the updated website directly to the organizers.

The organizers will evaluate the actual interface, check important functionality, and assign scores according to the criteria above.

Participants who achieve the highest scores will be considered for exclusive goodies.

Challenge 2: Build with Gemini — AI Chatbot Challenge

Time limit: 30–35 minutes

Maximum score: 100 points

Objective

Build a functional AI-powered chatbot using Gemini and the provided starter project.

This challenge focuses on integrating the Gemini API into an application and using an agent or tool to perform a useful action, rather than building only a static chat interface.

Your application should allow users to interact with the chatbot, receive useful responses, and use at least one meaningful tool or agent capability.

What You Need to Do

Open the starter repository and read its README and setup instructions.
Understand the existing codebase and identify the parts that need implementation.
Configure the required environment variables securely.
Integrate the Gemini API using the supported project setup.
Implement the chatbot's conversation flow.
Add or complete at least one useful tool or agent action.
Test the chatbot with different user inputs.
Demonstrate the application and explain its main functionality to the organizers.

Core Requirements

1. Gemini API Integration

Connect the application to the Gemini API.
Send user messages to the model and display the generated responses.
Handle loading states and API failures.
Store API keys in environment variables rather than hardcoding them.
Never expose private API keys in frontend code or a public repository.

2. Chatbot Functionality

Provide a clear interface for entering messages.
Display user messages and AI responses distinctly.
Handle empty input and basic errors appropriately.
Keep the conversation flow understandable and usable.

3. Agent or Tool Usage

Implement at least one useful tool or action appropriate to the application.

For example, the chatbot could:

Perform a calculation.
Search or filter information from a provided dataset.
Convert units.
Look up information from predefined local data.
Perform another meaningful action supported by the project.

The tool should do useful work and produce an understandable result. A button that does nothing or a tool that is never invoked does not demonstrate meaningful tool usage.

4. User Interface and Experience

Keep the interface clean and easy to navigate.
Make the chat input and response area readable.
Show loading or processing feedback.
Display understandable error messages.
Make the application usable on different screen sizes where practical.

Starter Project and Resources

GitHub repository: https://github.com/abhishek-nexgen-dev/AI-Chatbot-Challenge-Build-with-Gemini-API-Agents
Gemini API documentation: https://ai.google.dev/gemini-api/docs/get-started

Suggested Implementation Workflow

Time	Activity
First 5 minutes	Read the README, inspect the project, and understand the requirements
Next 10 minutes	Implement or complete Gemini API integration
Next 10 minutes	Implement chatbot behavior and the required tool or agent action
Next 5 minutes	Test the main features and fix obvious issues
Remaining 0–5 minutes	Prepare the demonstration and explain your implementation

This is a suggested time allocation, not a separate scoring rule. The total challenge time is 30–35 minutes.

Evaluation Criteria

Criterion	Points
Gemini API Integration	25
Agent and Tool Usage	30
Functionality and Response Quality	20
UI and User Experience	15
Creativity and Demonstration	10
Total	100

On-the-Spot Judging

Once the application is ready, participants must demonstrate it directly to the organizers.

The organizers may ask participants to:

Send a message to the chatbot and show the response.
Demonstrate the implemented tool or agent action.
Explain how the Gemini API is integrated.
Show that the application handles errors appropriately.
Explain the main implementation decisions.

The organizers will evaluate the working application and assign scores according to the published criteria.

Participants who achieve the highest scores will be considered for exclusive goodies.

Challenge 3: AI Faster Finger First Challenge

Time limit: 20 minutes

Maximum score: 10 points

Objective

Test your knowledge of Gemini CLI, Gemini API, and AI agents in this fast-paced multiple-choice question challenge.

This challenge rewards participants who can answer accurately and quickly.

Challenge Rules

10 multiple-choice questions.
1 point per correct answer.
Total: 10 points.
Answer as quickly and accurately as possible.
Submit your answers using the official challenge process.
The challenge must be completed within the 20-minute time limit.

Winner Selection

The first participant to submit all answers with the highest score wins!

First Code, First Serve: Participants who achieve the same highest score will be ranked based on their submission time. The participant who submits first will be declared the winner.

The organizers will verify the submitted answers and completion time before declaring the winner.

Submission Process

The AI Faster Finger First Challenge uses the official Google Form for answer submission.

Submission form: https://docs.google.com/forms/d/e/1FAIpQLScK-byoM9Dx4ieJt2ZHramhG5UGlZ6STxJu2wnYnUd9jv10HA/viewform?usp=dialog

Participants must ensure their answers are submitted successfully before the challenge deadline.

5. Help, Support and Announcements

Official WhatsApp Group

Join the official WhatsApp group for GDG Ranchi DevFest 2026 Gemini CLI Game Challenges to receive important updates and support.

Join here: https://chat.whatsapp.com/IMFmeH0VXX5C2Fn8hl7tfe?s=cl&p=a&mlu=4&ilr=4&iam=2

The group will be used to share:

Challenge instructions and important announcements.
Starter project and submission links.
Updates, clarifications, and reminders.
Help with setup and challenge-related issues.

Need help? Check the group announcements first. If you need immediate assistance during your challenge, contact a GDG Ranchi organizer or booth volunteer.

Joining the group does not replace completing your assigned challenge and demonstrating your work to the organizers.

Important Reminders

Complete your assigned challenge within the specified time.
Demonstrate your work directly to the booth organizers.
Keep your project and implementation ready for evaluation.
Follow the official instructions provided at the booth.
Do not share API keys, passwords, or other secrets.
For the AI Faster Finger First Challenge, ensure your answers are submitted through the official Google Form.

Thank You!

We look forward to seeing what you build at DevFest Ranchi 2026.

Explore Gemini CLI, experiment with your ideas, solve practical problems, and learn by building.

Build. Experiment. Demonstrate. Win!

Organized by Google Developer Groups (GDG) Ranchi.

GDG Ranchi DevFest Game 2026

Abhishek Gupta — Sun, 04 Oct 2026 16:45:20 +0000

Participant & Game Management System

1. Overview

This system will manage participants, games, game registrations, game submissions, scores, and the leaderboard for GDG Ranchi DevFest 2026.

The system will have only two roles:

Super Admin
Participant

The system will be independent of Commudle. Participants can register themselves through the website, while the Super Admin manages participants, games, and scores.

The main goal is to keep the system simple, reliable, and easy to operate during the event.

2. Main System Flow

                    GDG Ranchi Game System
                             │
              ┌──────────────┴──────────────┐
              │                             │
         SUPER ADMIN                   PARTICIPANT
              │                             │
      Manage Participants             Register Account
      Manage Games                     View Games
      Manage Registrations             Register for Game
      Manage Submissions               Submit Game
      Update Scores                    View Own Results
      View Leaderboard                 View Leaderboard
              │                             │
              └──────────────┬──────────────┘
                             │
                         LEADERBOARD

3. Roles

3.1 Super Admin

The Super Admin has complete control over the game management system.

Super Admin can:

Login to admin dashboard
View all participants
Search participants
Edit participants
Disable participants
Enable participants
Create games
Edit games
Activate games
Close games
View game registrations
View game submissions
Update participant scores
View participant game history
View leaderboard
Manage final event data

4. Participant

Participants use the public website/dashboard.

Participant can:

Register their account
Enter personal information
View their participant profile
View available games
Register for games
Submit completed games
View their registered games
View submitted games
View scores
View total points
View leaderboard
View their current rank

Participants cannot:

Edit their game score
Create games
Edit other participants
Disable participants
Manage the leaderboard
Manage other users

5. Participant Registration

Participants can register themselves through a public registration form.

Registration form

Name *
Email *
Mobile Number *
Organization
City
Profile Photo
Other required information
Password *
Confirm Password *

After successful registration:

Registration
     ↓
Create Participant Account
     ↓
Generate Participant ID
     ↓
Participant Dashboard

6. Participant ID

Every participant should receive a unique Participant ID.

Example:

GDG26-0001
GDG26-0002
GDG26-0003

The Participant ID can be used internally to identify a participant.

It should be:

Unique
Easy to read
Stable
Never reused

Example:

Participant ID: GDG26-0042
Name: Abhishek Kumar
Email: abhishek@example.com

7. Participant Status

Participants should not be permanently deleted by default.

Instead, use a status.

ACTIVE
DISABLED

Active

The participant can:

Login
Register for games
Submit games
View results

Disabled

The participant cannot:

Login
Register for new games
Submit games

However, their previous registrations and scores remain stored.

This protects historical event data.

8. Participant Dashboard

After login, the participant sees a simple dashboard.

┌─────────────────────────────────────┐
│ Welcome, Abhishek                   │
│ Participant ID: GDG26-0042          │
├─────────────────────────────────────┤
│ Total Games       5                 │
│ Completed Games   3                 │
│ Total Points      240               │
│ Current Rank      #12               │
└─────────────────────────────────────┘

Dashboard sections

Profile
Available Games
My Games
My Results
Leaderboard

9. Games

The Super Admin creates and manages games.

A game can contain:

Game Name
Description
Maximum Score
Start Time
End Time
Status

Example:

Game Name: Tech Quiz

Description:
Test your knowledge of technology and programming.

Maximum Score: 100

Start Time: 10:00 AM
End Time: 11:00 AM

Status: ACTIVE

10. Game Status

Every game should have a status.

UPCOMING
ACTIVE
CLOSED

UPCOMING

The game has not started yet.

Participants can see the game but cannot submit it.

ACTIVE

The game is currently available.

Participants can register and submit the game.

CLOSED

The game has ended.

New registrations/submissions should not be allowed.

11. Create Game

Only the Super Admin can create games.

Example:

Create Game

Game Name: Coding Challenge

Description:
Solve the given programming challenges.

Maximum Score: 100

Start Time: 2:00 PM
End Time: 3:00 PM

Status: UPCOMING

After creation:

Game
 ↓
UPCOMING
 ↓
ACTIVE
 ↓
CLOSED

12. Manage Games

The Super Admin can:

Create game
Edit game
Change game status
View registrations
View submissions
View results
Close game

Example admin table:

Game	Max Score	Registrations	Submissions	Status
Tech Quiz	100	450	430	Closed
Coding Challenge	100	320	300	Active
Memory Game	50	280	0	Upcoming

13. Game Registration

A participant can register for an available game.

Participant Dashboard
        ↓
Available Games
        ↓
Select Game
        ↓
Register
        ↓
Registration Successful

Example:

Tech Quiz

Maximum Score: 100
Status: ACTIVE

[ Register for Game ]

14. Duplicate Registration Protection

A participant must not be able to register for the same game twice.

For example:

Abhishek → Tech Quiz → Registered

If Abhishek tries again:

Already Registered

The backend must enforce this rule.

15. Game Submission

After registering and playing the game, the participant submits the game.

Example:

Tech Quiz
     ↓
Start Game
     ↓
Complete Game
     ↓
Submit Game

After submission:

Status: SUBMITTED
Score: 0
Points: 0

The initial score should be 0 by default.

The Super Admin can later update the actual score.

16. Score Management

Only the Super Admin can change scores.

Example:

Participant: Abhishek Kumar
Game: Tech Quiz

Current Score: 0

Maximum Score: 100

New Score: 85

[Update Score]

After update:

Score: 85
Points: 85

17. Score Validation

The backend must validate the score.

If:

Maximum Score = 100

Then:

0 ≤ Score ≤ 100

Invalid:

Score = 120

The backend should reject it.

The score should never be trusted only from the frontend.

18. Score and Points

The system should store both score and points.

For a simple implementation:

Score = 85
Points = 85

This gives flexibility if the event later wants different scoring rules.

For example:

Game Score = 80
Leaderboard Points = 100

The current implementation can simply use:

Points = Score

unless a different game-specific rule is required.

19. Participant Game History

Every participant should be able to see their game history.

Example:

My Games

Game                Score    Points    Status
------------------------------------------------
Tech Quiz             85       85      Submitted
Memory Game            70       70      Submitted
Coding Challenge       0        0       Registered
Puzzle Game            95       95      Submitted

At the bottom:

Total Games: 4
Completed Games: 3
Total Points: 250

20. Search Participant

The Super Admin should be able to search participants.

Search using:

Participant ID
Name
Email
Mobile number

Example:

Search: GDG26-0042

Result:

Abhishek Kumar
GDG26-0042
abhishek@example.com
9876543210

21. Participant Details Page

The Super Admin should be able to open a participant profile.

Participant Details
────────────────────────────

Name: Abhishek Kumar
Participant ID: GDG26-0042
Email: abhishek@example.com
Mobile: 9876543210
Organization: NexGen Studio
City: Ranchi

Status: ACTIVE

Game History
────────────────────────────

Game              Score    Points
Tech Quiz           85       85
Memory Game         70       70
Coding Challenge     0        0

Total Points: 155

The participant's profile image can also be displayed.

22. Manage Participants

The Super Admin can view all participants.

Example:

Participant ID	Name	Email	Mobile	Games	Points	Status
GDG26-0001	Rahul	rahul@example.com	98xxxxxx	4	280	Active
GDG26-0002	Priya	priya@example.com	97xxxxxx	3	210	Active
GDG26-0003	Amit	amit@example.com	96xxxxxx	2	120	Disabled

Actions:

View
Edit
Disable
Enable

23. Leaderboard

The leaderboard shows participants ranked by total points.

Example:

Rank	Participant	Games	Total Points
1	Rahul	5	450
2	Priya	5	420
3	Amit	5	390
4	Abhishek	4	350

The leaderboard should automatically update when scores change.

24. Ranking Calculation

The basic ranking rule:

Total Points =
Game 1 Points
+ Game 2 Points
+ Game 3 Points
+ ...

Example:

Tech Quiz          80
Memory Game        70
Coding Challenge   90
Puzzle Game        60
----------------------
Total Points      300

Leaderboard:

ORDER BY total_points DESC

25. Tie-Breaker

Tie-breaking should be decided before the event.

Recommended order:

1. Higher Total Points
2. Higher Highest Game Score
3. More Completed Games
4. Earlier Final Submission

For example:

Rahul       300 points
Abhishek    300 points

Then compare the next tie-breaker.

This avoids confusion when deciding the top 3 winners.

26. Top 3 Winners

The final leaderboard determines the winners.

🥇 Rank 1 → Winner
🥈 Rank 2 → Runner-up
🥉 Rank 3 → Third Place

The Super Admin should have a final leaderboard view for announcing winners and distributing goodies.

27. Admin Dashboard

The Super Admin dashboard should provide a quick overview.

┌────────────────────────────────────────────┐
│              ADMIN DASHBOARD               │
├────────────┬────────────┬──────────────────┤
│ Participants│ Games      │ Registrations    │
│     900     │     10     │      4,500       │
├────────────┼────────────┼──────────────────┤
│ Submissions│ Completed  │ Total Points     │
│    4,100    │    4,100   │     350,000      │
└────────────┴────────────┴──────────────────┘

Below that:

Recent registrations
Recent submissions
Top participants
Active games
Games requiring attention

28. Recommended Pages

Public Pages

/
├── Home
├── Register
├── Login
└── Leaderboard

Participant Pages

/dashboard
/profile
/games
/my-games
/my-results
/leaderboard

Super Admin Pages

/admin
/admin/participants
/admin/participants/:id
/admin/games
/admin/games/create
/admin/games/:id
/admin/registrations
/admin/submissions
/admin/scores
/admin/leaderboard

29. Database

For this system, PostgreSQL is a good choice.

The expected workload is small.

Even with:

900 participants
10 games

The maximum game registrations would roughly be:

900 × 10 = 9,000 registrations

This is very small for PostgreSQL.

There is no need to introduce Redis, RabbitMQ, Elasticsearch, microservices, or Kubernetes just for this system.

30. Main Database Tables

The system can start with these tables:

users
participants
games
game_registrations
game_results
score_update_logs

Optional:

activity_logs
email_logs

31. Users Table

Used for authentication.

users

id
name
email
password_hash
role
status
created_at
updated_at

Role:

SUPER_ADMIN
PARTICIPANT

32. Participants Table

Stores participant information.

participants

id
participant_id
user_id
name
email
mobile
image_url
organization
city
status
created_at
updated_at

Example:

id: UUID
participant_id: GDG26-0042
name: Abhishek Kumar
email: abhishek@example.com
mobile: 9876543210
status: ACTIVE

33. Games Table

games

id
name
description
max_score
status
start_time
end_time
created_at
updated_at

Example:

name: Tech Quiz
max_score: 100
status: ACTIVE

34. Game Registrations Table

This connects participants with games.

game_registrations

id
participant_id
game_id
status
registered_at
created_at
updated_at

Important database rule:

UNIQUE(participant_id, game_id)

This prevents duplicate registration.

35. Game Results Table

Stores the result of a game.

game_results

id
participant_id
game_id
score
points
status
submitted_at
updated_at
created_at

Default:

score = 0
points = 0

36. Score Update Logs

Whenever an admin changes a score, the system should keep a record.

score_update_logs

id
participant_id
game_id
old_score
new_score
old_points
new_points
updated_by
reason
created_at

Example:

Old Score: 70
New Score: 80

Updated By: Admin
Reason: Manual evaluation correction
Time: 2026-10-04 15:30

This is useful if a score is accidentally changed.

37. Database Relationship

USER
 │
 └──── PARTICIPANT
          │
          ├──────── GAME REGISTRATION
          │                 │
          │                 └──── GAME
          │
          └──────── GAME RESULT
                            │
                            └──── GAME

Simplified:

Participants
     │
     ├────< Game Registrations >──── Games
     │
     └────< Game Results >────────── Games

38. Backend Architecture

Recommended stack:

Frontend
React / Next.js

        ↓

Backend
Node.js
TypeScript
Express

        ↓

ORM
Prisma

        ↓

Database
PostgreSQL

External services:

Participant Image
       ↓
Cloudinary

Email
       ↓
Email Provider

39. Backend Structure

A simple structure is enough.

src/
│
├── modules/
│   ├── auth/
│   ├── participants/
│   ├── games/
│   ├── registrations/
│   ├── results/
│   └── leaderboard/
│
├── middleware/
│   ├── auth.ts
│   └── role.ts
│
├── database/
│
├── utils/
│
├── routes/
│
├── app.ts
└── server.ts

Keep modules separated by responsibility.

40. Authentication

Participants and Super Admin both need authentication.

Recommended:

Email
+
Password

Passwords must never be stored directly.

Store:

password_hash

Use a secure password hashing algorithm such as Argon2 or bcrypt.

41. Authorization

Authentication answers:

Who are you?

Authorization answers:

What are you allowed to do?

Example:

Participant
    ↓
GET /games
    ✓

Participant
    ↓
POST /games
    ✗

Super Admin
    ↓
POST /games
    ✓

Every protected backend operation should check the user's role.

42. Important Backend Rules

The backend should enforce:

Rule 1

Disabled participants cannot perform game actions.

Rule 2

Participant cannot register twice for the same game.

Rule 3

Participant cannot update their own score.

Rule 4

Only Super Admin can update scores.

Rule 5

Score cannot exceed maximum score.

Rule 6

Closed games cannot accept new submissions.

Rule 7

Leaderboard must use server-side data.

Rule 8

Participant can only view their own private profile/results.

Rule 9

Participant ID must be unique.

Rule 10

Important admin changes should be logged.

43. API Plan

Authentication

POST /auth/register
POST /auth/login
POST /auth/logout
GET  /auth/me

Participant

GET    /participants/me
PATCH  /participants/me
GET    /participants/me/games
GET    /participants/me/results

Admin Participants

GET    /admin/participants
GET    /admin/participants/:id
PATCH  /admin/participants/:id
PATCH  /admin/participants/:id/status

Games

GET    /games
GET    /games/:id

Admin Games

POST   /admin/games
PATCH  /admin/games/:id
PATCH  /admin/games/:id/status
DELETE /admin/games/:id

Instead of physically deleting an important game, it may be safer to close/archive it.

Game Registration

POST /games/:gameId/register
GET  /my-games

Game Submission

POST /games/:gameId/submit

Admin Results

GET   /admin/results
GET   /admin/results/:id
PATCH /admin/results/:id/score

Leaderboard

GET /leaderboard

44. Game Lifecycle

A game follows this lifecycle:

CREATE
  ↓
UPCOMING
  ↓
ACTIVE
  ↓
CLOSED

Participant:

Available
    ↓
Registered
    ↓
Playing
    ↓
Submitted
    ↓
Score Updated
    ↓
Completed

45. Complete Participant Flow

Participant visits website
          ↓
      Register
          ↓
    Account created
          ↓
 Participant ID generated
          ↓
       Login
          ↓
 Participant Dashboard
          ↓
     View Games
          ↓
 Select available game
          ↓
     Register Game
          ↓
       Play Game
          ↓
    Submit Game
          ↓
 Score = 0 initially
          ↓
 Super Admin evaluates
          ↓
 Score updated
          ↓
 Points calculated
          ↓
 Leaderboard updated
          ↓
 Participant sees result

46. Complete Admin Flow

Super Admin Login
       ↓
Admin Dashboard
       ↓
Manage Participants
       ↓
Manage Games
       ↓
Participants Register
       ↓
Participants Submit Games
       ↓
Admin Views Submissions
       ↓
Admin Updates Scores
       ↓
Points Updated
       ↓
Leaderboard Updated
       ↓
Final Top 3

47. Event-Day Workflow

The system should be designed for fast operation during the event.

Before Event

Create games
Configure maximum scores
Check participant registration
Test admin dashboard
Test game registration
Test score updates
Take database backup

During Event

Participant registers
        ↓
Participant joins game
        ↓
Participant submits game
        ↓
Admin checks submission
        ↓
Admin updates score
        ↓
Leaderboard updates

After Event

Close games
     ↓
Verify scores
     ↓
Verify leaderboard
     ↓
Confirm Top 3
     ↓
Distribute goodies
     ↓
Final database backup

48. Dashboard Statistics

Super Admin should see:

Total Participants
Active Participants
Disabled Participants

Total Games
Active Games
Closed Games

Total Registrations
Total Submissions

Total Points
Top 3 Participants

49. Performance Requirements

The system does not require complicated infrastructure.

Expected scale:

Participants: ~900
Games: ~10
Registrations: ~9,000 maximum
Results: ~9,000 maximum

A small PostgreSQL instance can easily handle this workload.

The bigger concern is not database performance.

The important things are:

Correct database constraints
Good validation
Reliable authentication
Backups
Stable hosting
Simple admin UI

50. Recommended Infrastructure

Simple production setup:

                Internet
                   │
                   ↓
             Web Application
                   │
                   ↓
             Node.js API
                   │
                   ↓
              PostgreSQL

Optional:

Participant Photo
       ↓
Cloudinary

Email
       ↓
Email Provider

For this event, avoid unnecessary services such as:

RabbitMQ       ❌
Redis          ❌
Kafka          ❌
Microservices  ❌
Kubernetes     ❌
Elasticsearch  ❌

A simple application is easier to maintain and safer during an event.

51. Backup Strategy

Because this system contains participant and game results, backups are important.

Recommended:

Before Event
     ↓
Database Backup
     ↓
During Event
     ↓
Periodic Backup
     ↓
After Event
     ↓
Final Backup

At minimum, keep a reliable database backup before the event begins.

52. Security

The system should include:

HTTPS
Password hashing
Secure authentication tokens/cookies
Role-based authorization
Input validation
Rate limiting for authentication
Server-side score validation
Unique database constraints
Secure environment variables
Database backups
Protection against unauthorized admin access

Never put:

DATABASE_URL
JWT_SECRET
EMAIL_PASSWORD
CLOUDINARY_SECRET

inside frontend code.

53. What Participants Can See

Participants should have a clean experience.

Dashboard
│
├── My Profile
│
├── Available Games
│
├── My Games
│
├── My Results
│
└── Leaderboard

They should not see admin functionality.

54. What Super Admin Can See

Admin Dashboard
│
├── Participants
│
├── Games
│
├── Registrations
│
├── Submissions
│
├── Scores
│
└── Leaderboard

55. Important UX Rules

Because this will be used during a live event:

Keep registration fast

Avoid unnecessary fields.

Show clear status

For example:

Registered ✓
Submitted ✓
Score Pending
Score: 85

Prevent accidental actions

For example:

Are you sure you want to disable this participant?

Make scores obvious

Current Score: 85 / 100

Make leaderboard easy to understand

Rank | Name | Games | Points

56. Error Handling

The system should show simple messages.

Instead of:

UNIQUE_CONSTRAINT_VIOLATION

Show:

You are already registered for this game.

Instead of:

FORBIDDEN

Show:

You don't have permission to perform this action.

Instead of:

BAD_REQUEST

Show the actual problem.

57. Development Plan

Phase 1 — Project Setup

Frontend
Backend
PostgreSQL
Prisma
Environment configuration

Phase 2 — Authentication

Register
Login
Logout
Role management
Protected routes

Phase 3 — Participants

Participant profile
Participant ID
Admin participant management
Enable/disable participant
Search

Phase 4 — Games

Create game
Edit game
Game status
Maximum score
Game listing

Phase 5 — Game Registration

Register for game
Duplicate protection
My games
Registration status

Phase 6 — Game Submission

Submit game
Submission status
Default score = 0
Admin submission list

Phase 7 — Scores

Admin score update
Score validation
Points calculation
Score update history

Phase 8 — Leaderboard

Total points
Ranking
Tie-breaker
Top 3

Phase 9 — Dashboard

Admin statistics
Participant dashboard
Game statistics
Recent activity

Phase 10 — Testing

Test:

Registration
Login
Participant permissions
Admin permissions
Game registration
Duplicate registration
Game submission
Score update
Invalid score
Leaderboard
Disabled participant

Phase 11 — Deployment

Production database
Production backend
Production frontend
HTTPS
Environment variables
Backups
Monitoring

58. Final Architecture

                    ┌───────────────────────┐
                    │       WEBSITE         │
                    │   React / Next.js     │
                    └───────────┬───────────┘
                                │
                                │ HTTPS
                                ↓
                    ┌───────────────────────┐
                    │       BACKEND         │
                    │ Node.js + TypeScript  │
                    │       Express         │
                    └───────────┬───────────┘
                                │
                                ↓
                    ┌───────────────────────┐
                    │      PostgreSQL       │
                    │                       │
                    │ Users                 │
                    │ Participants          │
                    │ Games                 │
                    │ Registrations         │
                    │ Results               │
                    │ Score Logs             │
                    └───────────────────────┘
                         │             │
                         │             │
                         ↓             ↓
                    Cloudinary       Email

59. Final Role Structure

There are only two roles.

SUPER ADMIN
│
├── Manage Participants
│   ├── View
│   ├── Search
│   ├── Edit
│   ├── Disable
│   └── Enable
│
├── Manage Games
│   ├── Create
│   ├── Edit
│   ├── Activate
│   └── Close
│
├── Manage Registrations
│
├── Manage Submissions
│
├── Update Scores
│
└── View Leaderboard

PARTICIPANT
│
├── Register
├── Login
├── View Profile
├── View Games
├── Register for Games
├── Submit Games
├── View Own Games
├── View Own Scores
├── View Total Points
└── View Leaderboard

60. Final Feature Checklist

Super Admin

[x] Login
[x] Dashboard
[x] Manage participants
[x] Edit participants
[x] Disable participants
[x] Enable participants
[x] Search participants
[x] Create games
[x] Manage games
[x] Activate/close games
[x] View registrations
[x] View submissions
[x] Update scores
[x] Score defaults to 0
[x] Score validation
[x] Score update history
[x] View leaderboard
[x] Final Top 3

Participant

[x] Self registration
[x] Login
[x] Participant ID
[x] Profile
[x] View available games
[x] Register for games
[x] Submit games
[x] View registered games
[x] View submitted games
[x] View individual scores
[x] View total games
[x] View total points
[x] View leaderboard
[x] View current rank

61. Final Recommended Stack

Frontend
React / Next.js
TypeScript

Backend
Node.js
Express
TypeScript

Database
PostgreSQL

ORM
Prisma

Authentication
JWT / Secure Cookie
Argon2 or bcrypt

Images
Cloudinary

Email
Resend / Brevo / SMTP

Hosting
Small VPS / Render / Similar

Version Control
Git + GitHub

The architecture should remain a single application initially.

62. Core Principle

The most important principle for this project is:

Keep the system simple enough that the GDG Ranchi team can operate it easily during the event.

We do not need a complicated distributed architecture for approximately 900 participants.

The core system is simply:

Participants
      ↓
Games
      ↓
Registrations
      ↓
Submissions
      ↓
Scores
      ↓
Points
      ↓
Leaderboard
      ↓
Top 3 Winners

Everything else exists to make this flow secure, reliable, and easy to manage.

63. Final System Summary

                GDG RANCHI DEVFEST 2026
                         │
              Participant Registration
                         │
                         ↓
                  Participant ID
                         │
                         ↓
                  Participant Login
                         │
              ┌──────────┴──────────┐
              ↓                     ↓
        View Available Games    View Leaderboard
              │
              ↓
        Register for Game
              │
              ↓
          Play Game
              │
              ↓
        Submit Game
              │
              ↓
        Score = 0 initially
              │
              ↓
         SUPER ADMIN
              │
              ↓
         Update Score
              │
              ↓
        Calculate Points
              │
              ↓
          Leaderboard
              │
              ↓
          ┌───┴───┐
          ↓       ↓
       Rank 1   Rank 2   Rank 3
          │       │       │
          └───────┴───────┘
                  ↓
             TOP 3 WINNERS

Final Scope

2 roles

6 core database concepts

Users
Participants
Games
Registrations
Results
Score Logs

1 backend

1 PostgreSQL database

1 participant flow

1 leaderboard

No unnecessary microservices.

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.