Forem: Shashi Bhushan Kumar

Interview #145: API: Difference between 500 vs 503 status codes?

Shashi Bhushan Kumar — Wed, 15 Apr 2026 20:03:11 +0000

The HTTP status codes 500 (Internal Server Error) and 503 (Service Unavailable) are both server-side error responses (part of the 5xx class), indicating that something went wrong on the server while processing a request. However, they serve distinct purposes and convey different meanings about the nature and cause of the error. Understanding the difference between them is critical for proper API design, error handling, and troubleshooting.
500 Internal Server Error
Definition:
The HTTP status code 500 indicates a generic server-side error. It means the server encountered an unexpected condition that prevented it from fulfilling the request, but it doesn’t provide specific information about what exactly went wrong.

When is 500 used?
Unhandled exceptions in the server code (e.g., null pointer exceptions, database failures, syntax errors).
Application crashes or configuration errors.
Bugs in server logic that result in failures during execution.
Any other error where the server knows something went wrong but can't pinpoint the issue to a specific client-side or temporary server condition.

Key Characteristics:
It typically means the problem is unintentional and unplanned.
It is often a sign of a programming or system error that needs fixing by developers or system admins.
It is a permanent error until the issue is resolved — retrying the request will likely continue to fail.

Example Scenario:
A user submits a form on a website, but the server throws a runtime exception due to malformed SQL. The user receives a 500 error because the backend couldn’t handle the request properly.

🔹 503 Service Unavailable
Definition:
The HTTP status code 503 indicates that the server is currently unable to handle the request, usually due to being temporarily overloaded, down for maintenance, or in a throttled state.

When is 503 used?
Server is undergoing maintenance (planned downtime).
The server is overloaded (e.g., traffic spike, DDoS protection).
Backend services or dependencies are temporarily unavailable.
API rate limits have been exceeded (in some implementations).

Key Characteristics:
It usually means the server is intentionally or temporarily unavailable.
It implies the server should recover — it's a transient issue.
A Retry-After header can be included to inform the client when to retry the request.

Example Scenario:
An API service is scheduled for maintenance between 1:00 AM and 2:00 AM. During this time, any request made receives a 503 status, possibly with a header like Retry-After: 3600 (indicating the client should wait an hour before retrying).

Best Practices in API Development
Use 500 only when an unexpected internal error occurs that the server could not handle.
Use 503 when the server is temporarily unable to process requests, but the situation is expected to resolve (like overload or maintenance).
Always log 500 errors internally and alert dev/ops teams.
When returning a 503, consider adding a Retry-After header to guide client behavior.
Don’t expose sensitive internal error details in 500 responses — use generic messages for security.

🔚 Conclusion
While both 500 and 503 status codes indicate server-side issues, they are fundamentally different in cause, expected recovery behavior, and how clients should respond. A 500 error suggests something went wrong unexpectedly and must be fixed, while a 503 signals that the service is temporarily unavailable, and retrying later might succeed. Proper use of these codes helps API consumers understand how to react and aids in faster issue diagnosis.

JavaScript Event Loop Explained Simply (With Diagram)

Shashi Bhushan Kumar — Mon, 06 Apr 2026 15:53:36 +0000

Understanding JavaScript Event Loop (With Simple Explanation + Diagram)

❗ Recently, I faced a question in an interview:

"Can you explain how JavaScript handles asynchronous operations?"

I thought I knew the answer… but explaining it clearly was not that easy.

So I decided to break it down and create a simple diagram to truly understand the Event Loop.

🧠 JavaScript is Single-Threaded

JavaScript runs on a single thread, which means it can execute only one task at a time.

To manage this efficiently, it uses:

Memory Heap → stores variables and objects
Call Stack → executes code

📞 Call Stack (Execution Area)

The Call Stack is where all synchronous code runs.

Example:

function a() {
  console.log("A");
}

function b() {
  a();
}

b();

👉 Execution:

b() goes into stack
a() goes into stack
Executes and pops out

🌐 Web APIs (Async Handlers)

JavaScript cannot handle async operations directly.

Instead, it uses Web APIs (provided by browser or Node.js runtime):

setTimeout
setInterval
fetch
DOM events

👉 These run in the background.

📥 Queues (Where Callbacks Wait)

After async work is completed, callbacks are placed into queues:

** Microtask Queue (High Priority)**
Promise.then()
async/await
🕐 Task Queue (Low Priority)
setTimeout
setInterval
DOM events
🔁 Event Loop (The Brain)

The Event Loop continuously checks:↴

Is the Call Stack empty?
Execute ALL Microtasks
Then execute ONE Task from Task Queue

👉 This process repeats again and again.

Important Behavior (Very Common Interview Question)

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

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

👉 Output:

Promise
Timeout

✔ Because Microtasks run before Tasks

💡 One-Line Summary
JavaScript uses:

Call Stack + Web APIs + Queues + Event Loop

to handle asynchronous operations without blocking execution.

Should One User Be Able to Add Multiple Reactions on the Same Post? 🤔

Shashi Bhushan Kumar — Mon, 16 Mar 2026 12:41:50 +0000

Should a single user be able to react multiple times on the same post? 🤔

Recently I noticed something interesting while using a developer community platform.

A single user can react with multiple reaction types on the same post.

For example:

❤️ Like
🦄 Unicorn
🔥 Fire
🙌 Celebrate
🤯 Mind-blown

One user can click several of these reactions on the same post.

On one hand, this is nice because it allows people to express different emotions about the same content.

But it also made me think about something from a user experience perspective.

If one person adds multiple reactions, the reaction count increases multiple times — even though it came from the same user.

For someone viewing the post, it might look like many people reacted, while in reality it could be just one person using several reactions.

So I’m curious to hear the community’s perspective.

What do you think is the better approach?

• Allow multiple reactions from the same user
• Allow only one reaction per user
• Show both total reactions and number of unique users
• Keep the current system because it encourages engagement

I’d really like to hear what other developers think about this.

Do you think this behavior is good for engagement, or could it create confusion in reaction counts?

I also opened a discussion in the open-source repository behind this platform to understand the community perspective:

👉 https://github.com/forem/forem/discussions/22941

Would love to hear your thoughts 👇

What do you think.?

Give Valuable Feedback In comment.👇

[Boost]

Shashi Bhushan Kumar — Sun, 15 Mar 2026 20:00:15 +0000

How I'm Preparing for My First Product Hunt Launch (As a Solo Dev)

egeindie ・ Feb 15

#startup #productivity #webdev #buildinpublic

How I Got My First Open Source Pull Request Merged (Beginner Guide)

Shashi Bhushan Kumar — Tue, 10 Mar 2026 04:00:00 +0000

My First Open Source Contribution Got Merged 🎉

Today is a special milestone in my developer journey.

My first pull request has been successfully merged into the @Forem open-source project — the platform that powers DEV Community, used by thousands of developers worldwide.

For many developers this might be a small contribution, but for me it means a lot.

How It Started

A few months ago, I didn't even know what open-source contribution really meant.

I started exploring GitHub projects and learning how developers collaborate on real-world software. While exploring different repositories, I discovered the @Forem project and found an issue that seemed interesting to work on.

That was the beginning of my open-source journey.

The Issue

The issue I worked on was related to reaction counters.

When users rapidly toggle reactions (like/unlike) on a post, the reaction counter could become inconsistent and sometimes even negative.

This happens because multiple requests can be processed quickly, causing the counter to lose synchronization with the actual number of reactions.

Issue Link:

https://github.com/forem/forem/issues/22803

The Goal

The goal was to ensure that reaction counters:

Always stay accurate
Never become negative
Stay consistent with the real number of reactions

Even when reactions are toggled rapidly.

What I Worked On

To solve this issue, I worked on improving how reaction counts are handled in the system.

The changes included:

Ensuring reaction counts remain non-negative
Keeping the counters consistent with actual reaction records
Adding tests to prevent this issue from happening again
Improving the handling of rapid reaction toggling

These improvements help maintain data integrity even during rapid user interactions.

The Pull Request

After implementing the fix and testing it locally, I submitted my pull request.

Pull Request Link:

https://github.com/forem/forem/pull/22865

The maintainers reviewed the code, suggested improvements, and after passing CI checks, the pull request was finally merged.

Seeing that "Merged" status was an amazing feeling.

What I Learned

This experience taught me several important things:

1️⃣ Open source is a great learning platform

You get to work on real-world codebases used by actual users.

2️⃣ Code reviews are valuable

Maintainers help improve your code and guide you toward better practices.

3️⃣ Small contributions matter

Even small fixes can improve the reliability of a large platform.

4️⃣ Collaboration is powerful

Open source is built by developers all over the world working together.

Advice for Developers Who Want to Start

If you are thinking about contributing to open source but feel unsure where to begin, here are a few tips:

Start with small issues
Read the project's contribution guidelines
Take time to understand the codebase
Don't be afraid to ask questions

Your first contribution doesn't need to be perfect. The most important step is simply getting started.

Final Thoughts

Contributing to open source has been an incredibly rewarding experience for me.

It allowed me to learn from real projects, collaborate with experienced maintainers, and contribute to software used by thousands of developers.

And this is just the beginning.

More open-source contributions coming soon

opensource #github #webdevelopment #devcommunity #softwareengineering #DevCommunity #Forem

Celebrating Women in Technology | International Women’s Day

Shashi Bhushan Kumar — Sat, 07 Mar 2026 12:32:33 +0000

🌸 Celebrating Women in Technology | International Women’s Day

Every year on March 8, the world celebrates International Women’s Day, recognizing the achievements and contributions of women across all industries.

In the technology sector, women are making incredible contributions — building innovative software, leading engineering teams, advancing artificial intelligence, and shaping the future of digital transformation.

Yet, the tech industry still needs greater diversity and inclusion.

Encouraging more women to pursue careers in STEM (Science, Technology, Engineering, and Mathematics) helps create stronger teams, better ideas, and more innovative solutions.

🚀 Women Are Transforming the Tech Industry

Today, women are actively contributing to many areas of technology, including:

💻 Software Development
🤖 Artificial Intelligence
🔐 Cybersecurity
📊 Data Science
☁️ Cloud Computing
🌐 Web Development

These contributions are shaping the future of the digital world.

💡 Why Diversity in Tech Matters

Diverse teams bring different perspectives, creativity, and problem-solving approaches.

Studies consistently show that inclusive teams build better products, better user experiences, and stronger companies.

Technology should be built for everyone, and that means everyone should be part of building it.

🎓 Education is the Key

One of the most powerful ways to empower future innovators is through education and access to learning resources.

Students and developers should have opportunities to learn programming, explore new technologies, and build real-world projects.

Platforms that provide accessible learning resources can help the next generation of engineers grow and succeed.

🌍 The Future of Technology is Inclusive

As developers, engineers, educators, and founders, we all have a role in supporting diversity and inclusion in tech.

Let’s continue encouraging more women to explore technology, build software, lead innovation, and inspire future generations.

Happy International Women’s Day! 🌸

👨‍💻 About the Author

Shashi Bhushan Kumar is a Full-Stack Developer and founder of SemesterExam.com, a platform that provides short notes and educational resources for B.Tech students.

He is passionate about building tools, platforms, and resources that make learning technology easier and more accessible for students.

What is Call Stack in JavaScript?

Shashi Bhushan Kumar — Fri, 27 Feb 2026 17:53:36 +0000

📚 What is Call Stack in JavaScript? (Explained Simply)

The Call Stack is where JavaScript executes your code.

It is a data structure that follows one simple rule:

👉 Last In, First Out (LIFO)

The last function added to the stack runs first.

🧠 How Call Stack Works

When a function is called:

It gets pushed into the Call Stack.
JavaScript executes it.
After completion, it gets removed (popped).

JavaScript can only execute one thing at a time,

so it uses the Call Stack to manage everything.

💻 Example

function first() {
  console.log("First");
}

function second() {
  first();
  console.log("Second");
}

second();

🔎 What Happens Internally?

second() is pushed into stack.
Inside it, first() is pushed.
first() runs and is removed.
Then second() continues.

🍽 Simple Real-Life Example

Imagine a stack of books.

You always place a book on top.

You always remove the top book first.

That’s exactly how Call Stack behaves.

🎯 Important Interview Point

The Call Stack works on:

Last In, First Out (LIFO)

Understanding this helps you understand:

Event Loop
setTimeout behavior
Stack overflow errors

setTimeout(0) Myth Explained Simply

Shashi Bhushan Kumar — Fri, 27 Feb 2026 03:06:00 +0000

⏳ setTimeout(0) Myth Explained Simply

Many beginners think:

setTimeout(fn, 0);

means the function runs immediately.

❌ Wrong.

It does NOT run instantly.

🧠 Why?

Because setTimeout is a Macrotask.

Even if the delay is 0, this is what happens:

It goes to Web APIs
Then it moves to the Macrotask Queue
The Event Loop waits until the Call Stack is empty
Then it executes

So 0 does NOT mean “run now”.

It means “run after current work is finished.”

💻 Example

console.log("Start");

setTimeout(() => {
  console.log("Timeout");
}, 0);

console.log("End");

✅ Output

Start
End
Timeout

🤔 Why Does "End" Come Before "Timeout"?

Because JavaScript runs in this order:

Synchronous code
Microtasks (Promises)
Macrotasks (setTimeout)

Since setTimeout is a macrotask,

it waits for the call stack to clear.

🍽 Simple Real-Life Example

Imagine you say:

“Call me after 0 minutes.”

Does that mean the person calls you immediately?

No.

It means:
👉 “Call me after whatever I’m doing right now is finished.”

That’s exactly how setTimeout(0) works.

🎯 Interview Point

setTimeout(0) does NOT mean immediate execution.

It means:

“Run after the current call stack is cleared.”

Building India’s Free B.Tech Notes Platform with Verified Certificates (MSME Registered Startup Story)

Shashi Bhushan Kumar — Thu, 26 Feb 2026 03:39:00 +0000

Canonical URL: https://www.semesterexam.com/blog/free-btech-notes-verified-contribution-certificate-india-2026

Building India’s Free B.Tech Notes Platform with Verified Certificates

Engineering students in India face a common problem.

Reliable, syllabus-specific, semester-wise notes are either hidden behind paywalls, outdated, or scattered across Telegram groups with zero credibility.

As an engineering student myself, I saw this gap clearly.

So instead of building another “notes selling website,” we built something different.

We built SemesterExam.com — a free, verified, student-powered academic platform.

The Core Idea

The idea was simple:

Free access to B.Tech notes
Free downloads
Free uploads
Verified contribution certificates
Transparent validation system
Real growth opportunities for students

No premium trap.
No hidden fees.
No fake promises.

100% Free Academic Access

On SemesterExam.com:

Students can read notes without login
Students can download notes after login (free)
Students can upload their own notes
Students can directly contact admin via support

Currently available for:

BPUT 7th Semester
MAKUT 7th Semester

And expanding through student requests.

🏅 Verified Contribution Certificates (With Public Validation)

Most platforms allow uploads.

But they don’t recognize contributors.

We changed that.

If a student uploads at least 6 verified notes, they receive:

Official Contribution Certificate
QR-based verification
Public validation page
Digital signature
Shareable PDF / PNG / JPG formats

Anyone can verify it online.

This makes it resume-ready and LinkedIn-shareable.

🏢 MSME Registered & ISO Under Process

SemesterExam.com is a registered MSME under Government of India.

Registration Number: BR-01-0049003

ISO 9001 certification is currently under process.

We are building for long-term credibility, not short-term traffic.

🤝 Talent Recognition Beyond Notes

If a student has skills in:

Content writing
SEO
Digital marketing
Video editing
Growth strategy

They can reach out via:

support@semesterexam.com

info@semesterexam.com

Exceptional talent may get part-time collaboration opportunities.

We don’t hire degrees.
We recognize ability.

🌍 The Bigger Vision

Engineering education in India needs collaboration, not competition.

We’re building a verified academic ecosystem where students:

Learn.
Contribute.
Get recognized.
Grow.

If you want to read the complete detailed article, you can check the full version here:

👉 https://www.semesterexam.com/blog/free-btech-notes-verified-contribution-certificate-india-2026

Let’s build something meaningful for students.

Microtask vs Macrotask Explained Simply

Shashi Bhushan Kumar — Wed, 25 Feb 2026 12:05:00 +0000

Microtask vs Macrotask Explained Simply

After understanding the Event Loop,

there is one more important concept:

👉 Microtask vs Macrotask

This is a very common interview question.

Let’s understand it in the simplest way possible.

First Understand This

When asynchronous tasks finish,

they don’t directly go to the Call Stack.

They go into queues.

But there are TWO types of queues:

Macrotask Queue
Microtask Queue

📦 What is a Macrotask?

Macrotasks are normal async tasks like:

setTimeout
setInterval
setImmediate (Node.js)
DOM events

Example:

setTimeout(() => {
  console.log("Macrotask");
}, 0);

setTimeout always goes to the Macrotask Queue.

⚡ What is a Microtask?

Microtasks are higher priority tasks like:

Promises (.then, .catch)
async/await
queueMicrotask

Example:

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

Promises go to the Microtask Queue.

🏃‍♂️ Which Runs First?

👉 Microtasks ALWAYS run before Macrotasks.

Even if setTimeout has 0 delay.

💻 Example

console.log("Start");

setTimeout(() => {
  console.log("Macrotask");
}, 0);

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

console.log("End");

✅ Output

Start
End
Microtask
Macrotask

🤔 Why This Happens

Execution order:

Synchronous code runs first
Microtasks run completely
Then one Macrotask runs
Again microtasks are checked

Microtasks have higher priority.

🍽 Real-Life Example

Imagine:

Macrotasks = normal customers

Microtasks = VIP customers

Restaurant rule:

Finish all VIP customers first
Then serve normal customers

That’s exactly how JavaScript behaves.

🎯 Important Interview Point

Priority order:

Synchronous code
Microtasks
Macrotasks

If interviewer asks:

“Which runs first, Promise or setTimeout?”

Answer:
Promise (Microtask) runs first.

Preparing for eLitmus 2026? Here’s a realistic 30-day strategy that actually works for B.Tech students managing college and placements.

Shashi Bhushan Kumar — Tue, 24 Feb 2026 15:00:13 +0000

eLitmus 2026 Preparation Guide: Complete 30-Day Strategy for B.Tech Students

Shashi Bhushan Kumar ・ Feb 24

#btech #aptitude #careeradvice #elitmus

eLitmus 2026 Preparation Guide: Complete 30-Day Strategy for B.Tech Students

Shashi Bhushan Kumar — Tue, 24 Feb 2026 14:58:24 +0000

How to Prepare for eLitmus 2026: Complete 30-Day Preparation Strategy for B.Tech Students

If you are searching for how to prepare for eLitmus 2026, this complete guide will give you a realistic and structured 30-day preparation roadmap.

Most articles give random study plans. This one is designed specifically for B.Tech students managing college, projects, internships, and placements.

Let’s break it down step by step.

What is eLitmus (pH Test)?

The eLitmus pH Test is a national-level placement aptitude exam used by companies to shortlist candidates based on:

Quantitative Aptitude
Logical Reasoning
Verbal Ability

Your score remains valid for one year, and companies contact you directly based on your percentile.

For many freshers, it becomes an additional opportunity apart from campus placements.

eLitmus 2026 Syllabus (Updated Overview)

Before starting preparation, understanding the syllabus is important.

Quantitative Aptitude

Percentages
Profit & Loss
Ratio & Proportion
Average
Time & Work
Speed & Distance
Number System
SI & CI
Data Interpretation

Logical Reasoning

Number & Alphabet Series
Coding-Decoding
Blood Relations
Direction Sense
Seating Arrangement
Syllogism
Logical Puzzles

Verbal Ability

Reading Comprehension
Grammar
Error Detection
Para Jumbles
Vocabulary

30-Day eLitmus Preparation Plan (Realistic Version)

This plan assumes 3–4 hours of daily study.

The goal is consistency, not over-studying.

Week 1: Build Strong Quant Foundation

Focus completely on Arithmetic basics.

Day 1–2: Percentages + Profit & Loss

Day 3: Ratio & Proportion

Day 4: Average

Day 5: Time & Work

Day 6: Speed & Distance

Day 7: Sectional Test + Revision

Goal: Concept clarity and accuracy.

Week 2: Advanced Quant + Reasoning Start

Day 8: Number System

Day 9: Simple & Compound Interest

Day 10: Data Interpretation

Day 11: Series (Number & Alphabet)

Day 12: Coding-Decoding

Day 13: Blood Relations + Direction

Day 14: Sectional Mock + Analysis

Important: Learn patterns, not shortcuts only.

Week 3: Logical Depth + Verbal Improvement

Day 15–16: Seating Arrangement + Puzzles

Day 17: Syllogism + Statement-Conclusion

Day 18: Grammar Basics

Day 19: Error Detection

Day 20: Para Jumbles

Day 21: Full-Length Mock Test

After every mock, spend at least 1–2 hours analyzing mistakes.

Week 4: Mock & Performance Phase

This is the most important phase.

3 Full-Length Mock Tests
2 Sectional Speed Tests
Daily Weak Topic Practice
1 Reading Comprehension daily

Target:

70%+ accuracy
Strong reasoning section
No blind guessing

Remember: Accuracy matters more than attempts.

Common Mistakes Students Make in eLitmus Preparation

Ignoring Logical Reasoning
Attempting all questions randomly
Not analyzing mock tests
Memorizing formulas without practice
Leaving Verbal section preparation

Avoid these, and your score improves automatically.

How to Maximize Your eLitmus Score in 2026

Focus on solving previous-level questions
Track weak topics in a notebook
Improve reading speed
Practice under time pressure
Stay consistent for 30 days

Even average students can perform well with structured preparation.

Who Should Give eLitmus?

Final-year B.Tech students
Freshers targeting private and product companies
Students looking for off-campus opportunities
Candidates confident in aptitude but improving coding skills

Final Thoughts

If you consistently prepare for 30 focused days with proper mock analysis, cracking eLitmus 2026 is completely achievable.

Consistency > Motivation

Analysis > Blind Practice

Placement exams reward discipline more than intelligence.

I regularly write about JavaScript, placements, and B.Tech preparation strategies.

If this guide helped you, consider sharing it with someone preparing for placements.