Preamkumar Revathi’s Post

Day 14 – Node.js Handling POST Request Body Today I implemented request body handling using pure Node.js. Since request data comes as a stream, we must manually collect chunks using req.on('data') and process them in req.on('end'). Understanding this helps build a strong foundation before using frameworks like Express. Next: Introduction to Express.js 🚀 #NodeJS #BackendDevelopment #JavaScript #WebDevelopment #SoftwareEngineering

🚀 What I Learned Today: Node.js Internals • Node.js runs JavaScript on a single main thread • Top-level code executes first before the event loop starts • Import statements load during initialization • Event Loop manages asynchronous operations Event Loop Phases: • Timers → setTimeout() / setInterval() • I/O Polling → file system & network operations • Check → setImmediate() (Node.js specific) • Close Callbacks → cleanup tasks • Node.js uses a libuv worker thread pool (default: 4 threads) • Thread pool size can be changed using process.env.UV_THREADPOOL_SIZE https://lnkd.in/gwFG5WVW thank you Piyush Garg sir Hitesh Choudhary sir Akash Kadlag sir #chaiaurcode #NodeJS #JavaScript #Backend #EventLoop

🚀 I Finally Understood the Node.js Event Loop And it made Node.js make so much more sense. Most developers use Node.js daily. But very few understand what happens behind the scenes. Here are 3 things I learned today 👇 🔹 1. Node.js Uses libuv libuv powers the event loop and handles async tasks like: • File operations • Network requests • Timers This is why Node.js is non-blocking and scalable. 🔹 2. Before the Event Loop Starts Node.js first: • Initializes the environment • Executes top-level code • Loads modules (require / import) • Registers callbacks Only then does the event loop begin. 🔹 3. Event Loop Phases Once running, Node.js processes tasks in phases: 1️⃣ Timers 2️⃣ I/O callbacks 3️⃣ Polling 4️⃣ setImmediate 5️⃣ Close callbacks Understanding this helps write better async code. Big thanks to Hitesh Choudhary, Piyush Garg, Jay Kadlag for the amazing explanation. #NodeJS #JavaScript #BackendDevelopment #WebDevelopment

Day 6 – Node.js Understanding async/await Today’s topic: async/await in Node.js. async/await is built on top of Promises and makes asynchronous code easier to read and maintain. Instead of using .then() and .catch(), we can write asynchronous code that looks like synchronous code. Key points: • async makes a function return a Promise • await pauses execution until the Promise resolves • Error handling is done using try/catch • Avoids callback nesting async/await improves readability and structure in real-world backend applications. Next: Node.js Core Modules (fs, path, os) #NodeJS #BackendDevelopment #JavaScript #AsyncProgramming #SoftwareEngineering

A small TypeScript feature that can save your hours of debugging 👇 Strict typing for API responses. Earlier in JavaScript, if an API response changed slightly, the error would only appear at runtime. Now I define API responses like this: interface UserResponse { id: string email: string createdAt: Date } If the backend response changes, TypeScript immediately throws an error during development. This has been extremely helpful when working with: • Microservices • Event-driven systems • Database schemas Especially in large backend systems where multiple services depend on the same data contract. Lesson learned: Good types = fewer production bugs. #TypeScript #NodeJS #BackendDevelopment

React 19 makes refs simple One of the most awkward React APIs is finally cleaned up. Earlier, passing refs meant: - forwardRef boilerplate - TypeScript generic issues - Extra wrapper components import { forwardRef } from "react"; const Input = forwardRef(function Input(props, ref) { return <input ref={ref} {...props} />; }); With React 19, ref is just a regular prop. function Input({ ref, ...props }) { return <input ref={ref} {...props} /> } - No forwardRef - No HOC - Just clean, predictable React A small change that significantly improves developer experience, especially for reusable component libraries in React. #React19 #FrontendEngineering #JavaScript #TypeScript #DeveloperExperience

🚨 Node.js is NOT actually single-threaded One of the biggest misconceptions I had early in backend development: “Node.js can only handle one thing at a time.” Not true. Node runs JavaScript on a single thread but under the hood it uses: Event Loop Worker Threads libuv thread pool Meaning: - File system operations - Database queries - Network requests are executed outside the main thread. The real bottleneck isn’t Node itself, it’s CPU-blocking code. 💡 Lesson: Node excels at I/O-heavy systems, not CPU-heavy computation. That’s why companies use Node for APIs but offload heavy processing to workers or services. 💬 Question: What surprised you most when you learned how Node actually works? #NodeJS #BackendEngineering #SystemDesign #JavaScript #FullStackDev #SoftwareEngineering #TechInsights

The "Magic" of the Node.js Event Loop, Explained. Tonight’s Chai Aur Code session was a deep dive into the internals of Node.js. It’s one thing to write a server; it's another to understand how it actually breathes. 🧠 The execution flow we broke down: 1️⃣ Initial Phase: Top-level code runs first, followed by imports. 2️⃣ Registration: Event callbacks are registered. 3️⃣ The Event Loop: This is where the real work happens in 4 distinct phases: - Expired Callbacks: Processing setTimeout and setInterval. - I/O Polling: Handling network, file systems, etc. - setImmediate(): The "Check" phase. - Close Callbacks: Wrapping up resources. Understanding these internals changes how you think about performance and asynchronous logic. Huge thanks to Piyush Garg for the clarity! Anirudh J. Hitesh Choudhary Akash Kadlag Jay Kadlag #NodeJS #BackendDevelopment #JavaScript #ChaiAurCode #SoftwareEngineering #BuildInPublic #HiteshChoudhary