React State Not Updating After API Call Fix

🚀 Day 6/50 – Backend Mastery Series Every API response you receive… Looks something like this 👇 { "name": "Prathamesh", "role": "Backend Developer", "experience": 1 } But what exactly is this format? 🤔 Today, let’s understand JSON. 📦 What is JSON? JSON (JavaScript Object Notation) is a lightweight data format used to exchange data between Client and Server. It is: ✅ Easy to read ✅ Easy to write ✅ Lightweight ✅ Language-independent Even though it comes from JavaScript, almost every backend language supports JSON. 🔹 Why JSON is Important? Because when: • Frontend sends data → It sends JSON • Backend responds → It returns JSON • APIs communicate → They use JSON Without JSON, modern web apps wouldn’t work smoothly. 🛠 JSON Structure JSON is written in key-value pairs. Example: { "id": 101, "username": "john123", "isAdmin": false } 👉 Keys are always in double quotes 👉 Data can be string, number, boolean, array, or object 💡 Real Example When a user logs in: Frontend sends: { "email": "user@gmail.com", "password": "123456" } Backend verifies and responds with: { "message": "Login Successful", "token": "jwt_token_here" } That’s JSON in action. Understanding JSON is fundamental for every Backend & Full Stack Developer. This is Day 6 of 50 Days of Backend Mastery 🔥 Tomorrow: What is Node.js & Why It’s Powerful? Follow along if you're serious about backend growth 🚀 #BackendDevelopment #JSON #API #FullStackDeveloper #WebDevelopment #LearnInPublic

🚀 Day 7/100 ---- Built My First REST API Using Node.js (Without Express!) Today I took a deep dive into how backend APIs actually work under the hood. Instead of using frameworks like Express, I built a Task Management REST API using Node.js’ native http module to understand the fundamentals. Here’s what I learned while building it: 🔹 REST API Design I implemented endpoints for a simple task manager: GET /tasks → fetch all tasks GET /tasks/:id → fetch a single task POST /tasks → create a task PATCH /tasks/:id → update a task DELETE /tasks/:id → delete a task 🔹 Understanding the Request Lifecycle A request flows through several layers: Client → Server → Router → Controller → Data Layer → Response 🔹 Handling Request Bodies in Node.js Since the native http module doesn't parse request bodies automatically, I implemented my own parseBody() function to collect data chunks from the request stream and convert them into JSON. 🔹 Async File Storage Tasks were stored in a local JSON file and accessed using asynchronous file operations (fs.promises) to simulate a simple database. 🔹 Proper HTTP Practices I also implemented proper: Status codes (200, 201, 204, 400, 404, 500) JSON responses Error handling Input validation What surprised me most is how much frameworks abstract away. Building this from scratch helped me truly understand how APIs process requests and responses. This project gave me a solid foundation in: ✅ Node.js core modules ✅ REST architecture ✅ Asynchronous programming ✅ Backend project structure Next step: adding pagination, filtering, and middleware logging to make the API closer to a production-ready service. If you're learning backend development, I highly recommend building at least one API without a framework — it really clarifies how everything works. Checkout the code: https://lnkd.in/eGhBrdED Chris Nyeche #NodeJS #BackendDevelopment #RESTAPI #JavaScript #SoftwareEngineering #LearningInPublic

“Uploading a file” sounds easy… Until you implement it in the backend. ⚙️ This week, I built file upload functionality using **Multer middleware** in Express.js — and it completely changed how I understand the request lifecycle in Node.js. 🚀 Here’s what actually happens: When a client sends `multipart/form-data`, Express cannot handle it by default. ❌ Multer acts as a middleware layer that: • 🔄 Intercepts the request • 📂 Processes incoming files • 📎 Attaches them to `req.file` or `req.files` • 🧱 Passes structured data to the controller Example: ```javascript router.route('/register').post( upload.fields([ { name: "avatar", maxCount: 1 }, { name: "coverImage", maxCount: 1 } ]), registerUser ); ``` Key concepts I strengthened: • 🔹 `.single()` vs `.array()` vs `.fields()` • 🔹 Difference between `req.file` and `req.files` • 🔹 How middleware fits into clean backend architecture • 🔹 Why file validation is critical for security 🔐 • 🔹 Separating concerns between middleware and controllers 💡 Big realization: Backend development is not just about building routes. It’s about controlling data flow, enforcing structure, and thinking about security at every layer. Small features like file uploads teach big architectural lessons. If you’re learning backend — what concept recently changed your understanding? 👇 #BackendDevelopment #NodeJS #ExpressJS #JavaScript #WebDevelopment #Multer #SoftwareEngineering #LearningInPublic

Excited to share that my latest project is live! ERMS (Event & Resource Management System) a full-stack web application built to streamline how  organizations manage their resources and bookings.  What it does:  - Browse and book resources like conference rooms, equipment, and vehicles  - Submit booking requests with time-slot management  - Admin dashboard for approving/rejecting bookings, managing users, and tracking resource usage  - Role-based access control (User, Moderator, Super Admin)  Tech Stack:  - Frontend: React, TypeScript, Tailwind CSS, Vite  - Backend: Node.js, Express, TypeScript, Prisma ORM  - Database: PostgreSQL (Neon)  - Deployment: Vercel (Serverless)  - Auth: JWT with refresh token rotation  Key highlights:  - Fully responsive UI with a clean, modern design  - Secure authentication with rate limiting and input validation  - RESTful API with Swagger documentation  - Production-ready deployment with CI/CD via Vercel  This was a great learning experience in building a complete full-stack application from scratch.Check it out on the link below: https://lnkd.in/djw3wrE6  #WebDevelopment #React #TypeScript #NodeJS #Express #PostgreSQL #FullStack #SoftwareEngineering #BuildInPublic

🚀 Building Production-Grade Systems, Not Just Features Currently engineering a full-stack blog platform — treating it not as a simple CRUD app, but as a real-world backend system designed for scale and longevity. 🛠️ Tech Stack React • Node.js • Express • Prisma ORM • PostgreSQL • JWT • TypeScript 🏗️ What makes this different? I'm approaching this with a systems-first mindset: → Designing granular RBAC (Admin/Author/User) with clear permission boundaries → Implementing stateless JWT authentication with layered middleware guards → Structuring a modular, feature-driven architecture that scales with complexity → Managing schema evolution safely through Prisma migrations → Enforcing strict type safety to catch errors before runtime → Building lifecycle-aware image storage handling 💡 The Core Philosophy Separation of concerns over convenience Scalable authorization logic over hardcoded checks Clean controller-service abstractions over monolithic handlers Thoughtful database modeling over quick fixes Testable, readable, extensible code over "it works" The goal isn't just to ship — it's to build systems that evolve gracefully as product requirements grow. Engineering is about making tomorrow's changes easier, not just solving today's problems. #SoftwareEngineering #FullStackDevelopment #SystemDesign #NodeJS #React #TypeScript #Backend

Is backend development all about database and API? Well, calling backend development just "database and API" is like saying cooking is just chopping vegetables and boiling water. Yes those are part of it. But that's not the whole picture. Backend is where the real logic lives. Authentication, authorization, business rules, caching, queues, error handling, security, performance optimization. The parts users never see but experience every single time something just works. Frontend is what users interact with. Backend is what makes that interaction meaningful. REST API is the contract between the two. You can have the most beautiful UI in the world. Without a solid backend it's just a pretty interface that does nothing. So next time someone says backend is just database and API, show them this bike. 🚲 w3schools.com JavaScript Mastery #backend #frontend #fullstack #api

Nodemon or Doraemon? 😄 | Smart Shortcuts for Faster Node.js Development When developers start building a Node.js backend, many of us do everything manually. But knowing a few smart shortcuts can make development much faster and smoother. 🔹 Use nodemon Normally, when you run a Node server, you have to manually restart it every time you change the code. With nodemon, the server automatically restarts whenever a file change is detected, which keeps the development flow smooth. 🔹 Use Environment Variables Sensitive information like database URLs, API keys, or secret keys should never be hardcoded. Instead, store them in a .env file and manage them easily using the dotenv package. This keeps your project cleaner and more secure. 🔹 Use Express Generator or Boilerplates Instead of creating the folder structure from scratch, using a basic Express boilerplate can save a lot of time. It already provides routing and middleware setup so you can focus on the core logic. 🔹 Async Error Handling Wrapper Writing try/catch repeatedly in every async route can make code messy. A small helper wrapper function can keep routes clean and improve readability. 🔹 Use Mongoose Schemas for MongoDB If you’re working with MongoDB, Mongoose schemas allow you to define validation, default values, and data structure in one place. This reduces repetitive manual checks. 🔹 Use Proper Logging Tools console.log works for debugging, but in larger applications tools like winston or morgan help track request logs and system events more effectively. 🔹 Follow Modular Code Structure Keeping routes, controllers, services, and models in separate files makes the code easier to maintain, scale, and collaborate on. 💡 In short: Node.js shortcuts aren’t hacks. They are simply smart tools and structured practices that help developers build faster and maintain better code. #NodeJS #BackendDevelopment #WebDevelopment #JavaScript #SoftwareEngineering #CodingTips

Most beginner Node.js projects look like this: index.js routes.js controllers.js Everything in one place. It works for small apps. But as the backend grows, the code becomes difficult to maintain. A more scalable structure I have been studying while working with Node.js and Express.js looks like this: src/ controllers → handle HTTP requests services → business logic layer routes → define API endpoints models → database schemas middlewares → authentication, rate limiting validators → request validation config → environment & database configuration utils → reusable helpers jobs → background workers / queues loaders → initialize services (DB, cache) app.js → application entry point Why this structure works well: • Controllers stay thin • Business logic lives in services • Middlewares handle cross-cutting concerns (auth, logging) • Validators protect APIs from bad input • Jobs handle async tasks like emails or notifications This separation helps keep the backend clean, scalable, and production-ready. I am currently exploring how production backend systems are structured beyond simple CRUD APIs. Backend engineers what additional layers do you usually include in your architecture? #BackendDevelopment #NodeJS #SoftwareArchitecture #SystemDesign

Shipped a solid refactor on my Job Tracker app this week Simplified the architecture by removing over-abstracted shared components Split UI into explicit domain components for Companies and Connections Cleaned up dead files + debug code Updated README with real project docs: file structure, user flow, and tech stack Big takeaway: sometimes “less reusable” code is actually more maintainable when it improves clarity. Built with Next.js, React, Prisma, PostgreSQL, and NextAuth. #webdevelopment #nextjs #reactjs #prisma #softwareengineering #buildinpublic

Backend Fundamentals: Node.js, Express & MongoDB 1. Basics Node.js is not JavaScript itself. It is a runtime environment that allows JavaScript to run outside the browser. Structure: JavaScript (Language) → Node.js (Runtime) → Express (Framework) Node.js makes server creation possible. Express makes it easier and cleaner. 2. Node vs Express Node.jsExpressManual routingBuilt-in routingMore boilerplateCleaner codeLow-levelHigh-levelHarder to scaleEasier to scale Node.js gives control. Express gives simplicity and speed. 3. Basic Express Server const express = require('express'); const app = express(); app.get('/', (req, res) => { res.send('Server running'); }); app.listen(3000); 4. Postman & Agent Postman = API testing tool Postman Desktop Agent = Required to test local APIs Agent alone does nothing. It works with Postman. 5. Request–Response Cycle Frontend → Request → Backend → Logic → Response → Frontend Middlewares can modify requests before they reach routes. 6. MongoDB Basics SQL → Table MongoDB → Collection SQL → Row MongoDB → Document CRUD Operations: Create Read Update Delete Express + MongoDB = Complete backend system.