API Types Every Developer Should Know

I kept forgetting important tasks… so I built something to fix it ⏰ I created AssignMate — a full-stack task reminder app that actually reminds you before it’s too late. 🚀 What it does: • Add tasks with date & time • ⏰ Sends reminder 10 minutes before deadline • 🌅 9 AM: Daily summary of all tasks • 🌆 6:30 PM: Overdue task reminder • 🔐 Secure authentication using Clerk • Tracks completed tasks • Clean and responsive UI 💡 Why I built this: I wanted a system that doesn’t just store tasks, but actively reminds me at the right time — like a real assistant. ⚙️ Tech Stack: • React • Node.js + Express • MongoDB • Node-Cron • Clerk (Authentication) • Brevo (Email API) 🔗 Live Demo: https://lnkd.in/gWuP4C8F 💻 GitHub: https://lnkd.in/gx4dED35 🧠 What I learned: • Real-world reminder system design • Backend scheduling using cron jobs • Email automation • Full-stack integration Would love your feedback 🙌 🔜 Next: Adding daily & weekly recurring tasks #webdevelopment #fullstack #reactjs #nodejs #mongodb #projects #learning #developers #clerk

Today I explored Multer for the first time… and it unlocked a missing piece in my project I had been building features, APIs, UI… everything looked fine. But one thing was missing i.e file uploads. 💡 So, what exactly is Multer? 👉 Multer is a Node.js middleware 👉 It handles multipart/form data 👉 Which basically means: uploading files (images, docs, etc.) 📦 In simple words: It helps your backend receive → process → store files without chaos. ⚙️ Where I used it in my project: I’m building a property listing platform :- Here’s the flow: 📤 User uploads property images ⬇️ 📁 Multer stores them in /uploads (backend) ⬇️ 🗂️ Image paths saved in database ⬇️ 🖼️ Images rendered dynamically on frontend 🔥 The interesting part: Until now → my project was just handling text After this → it started handling real-world data And honestly… Seeing uploaded images appear on the UI felt different 😄 👉 That’s when it stopped feeling like just a project. 💬 Curious: What’s that one feature that made your project feel more real? #Multer 🚀 #NodeJS ⚡ #MERNStack 💻 #BackendDevelopment 🔧 #WebDevelopment 🌐 #FullStackDeveloper 👨💻 #MongoDB 🍃 #ExpressJS 🚂 #ReactJS ⚛️ #DevelopersIndia 🇮🇳 #LearnInPublic 📚 #CodingJourney 🛤️ #SoftwareEngineer 🧠 #BuildInPublic 🏗️ #100DaysOfCode 🔥

Day 5 When I was a junior dev, this line of code confused the hell out of me: const response = await fetch(url) const data = await response.json() I kept asking — why TWO awaits? Why can't fetch just give me the data directly? So I stopped copy-pasting and went back to first principles. Here's what I learned: → 200 OK does NOT mean the data arrived. It just means the server is saying, "I got your request, here comes the response." The connection is still open. The body is still travelling through the wire. → fetch() returns a promise for the headers first. That's the first await — waiting for the server to respond and say "200 OK." → response.json() returns a second promise for the body. That's the second await — waiting for all the actual data to arrive and parse. Think of it like a phone call. When someone picks up and says "hello" — that's the 200. But you haven't heard the actual message yet. You wait. They speak. Now you have the data. Once I understood THAT — promises stopped feeling scary. I stopped seeing async/await as magic syntax. I started seeing it as: "wait here until the data actually arrives." First principles thinking didn't just teach me promises. It changed how I debug, how I read docs, and how I learn anything new in tech. Stop memorising patterns. Start asking WHY they exist. That one question will make you a better developer faster than any tutorial. — — — What concept finally clicked for you when you went back to first principles? Drop it in the comments 👇 #JavaScript #WebDevelopment #Promises #AsyncAwait #JuniorDeveloper #FirstPrinciples #Programming #SoftwareEngineering #TechCommunity #CodingTips #LearnToCode #NodeJS #Frontend #Backend #Developer

Many developers (including me earlier) get confused about this: Can we fetch data using POST? And what exactly is req.params? While building my backend project, I mixed up these concepts a lot. At first, I thought: GET → fetch data POST → only send data But later I realized that POST can also return data in the response. For example, login APIs send back user data or tokens. Still, best practice is: GET for fetching POST for creating or processing Then comes req.params. I used to think it depends on GET or POST, but it doesn’t. req.params is just used to get values from the URL. Example: Route → /user/:id Request → /user/123 Then: req.params.id gives 123 And this works for both GET and POST. That cleared a lot of confusion for me while building APIs. Anyone else got confused with this while learning backend? #BackendDevelopment #Nodejs #Expressjs #API #Learning #WebDevelopment #FullStackDevelopment

GraphQL Series — Day 1 Ever felt like your API gives you too much data… or not enough? 🤔 That’s exactly the problem GraphQL solves. 👉 Instead of multiple endpoints like REST, GraphQL gives you one endpoint 👉 You request only the data you need 👉 No more over-fetching or under-fetching 💡 In simple terms: GraphQL lets the frontend control the data it receives. When to use GraphQL? ✔ When your UI needs flexible data ✔ When multiple clients need different data ✔ When performance matters When REST is enough? ✔ Simple apps ✔ Fixed data structure ✔ Easy caching needs Follow for more frontend insights 📘 #GraphQL #Frontend #FrontendDevelopment #WebDevelopment #JavaScript #ReactJS #APIs #TechLearning #LearnInPublic #DevCommunity #FrontendEngineer #100DaysOfCode

🚀 Day 38 – Node.js Core Modules Deep Dive (fs & http) Today I explored the core building blocks of Node.js by working directly with the File System (fs) and HTTP (http) modules — without using any frameworks. This helped me understand how backend systems actually work behind the scenes. 📁 fs – File System Module Worked with both asynchronous and synchronous operations. 🔹 Implemented: • Read, write, append, and delete files • Create and remove directories • Sync vs async execution • Callbacks vs promises (fs.promises) • Error handling in file operations • Streams (createReadStream) for large files 🔹 Key Insight: Streams process data in chunks, improving performance and memory efficiency. Real-time use cases: • Logging systems • File upload/download • Config management • Data processing (CSV/JSON) 🌐 http – Server Creation from Scratch Built a server using the native http module to understand the request-response lifecycle. 🔹 Explored: • http.createServer() • req & res objects • Manual routing using req.url • Handling GET & POST methods • Sending JSON responses • Setting headers & status codes • Handling request body using streams 🔹 Key Insight: Frameworks like Express are built on top of this. ⚡ Core Concepts Strengthened ✔ Non-blocking I/O → No waiting for file/network operations ✔ Event Loop → Efficient handling of concurrent requests ✔ Single-threaded architecture with async capabilities ✔ Streaming & buffering → Performance optimization Real-World Understandings • How client requests are processed • How Node.js handles multiple requests • What happens behind APIs • Better debugging of backend issues Challenges Faced • Managing async flow • Handling request body streams • Writing scalable routing without frameworks 🚀 Mini Implementation ✔ File handling using fs ✔ Basic HTTP server ✔ Routing (/home, /about) ✔ JSON response handling Interview Takeaways • Sync vs Async in fs • Streams in Node.js • Event Loop concept • req & res usage #NodeJS #BackendDevelopment #JavaScript #LearningJourney #WebDevelopment #TechGrowth 🚀

🧵 Buffer vs Stream in Node.js — A concept every developer should understand! When dealing with data in programming, two fundamental approaches define HOW and WHEN data is processed: ━━━━━━━━━━━━━━━━━━━━━ 📦 BUFFER ━━━━━━━━━━━━━━━━━━━━━ A buffer collects ALL data in memory FIRST, then processes it. Think of it like filling a bucket of water completely before using it. ✅ Simple to use ✅ Easier to manipulate (slice, copy, transform) ❌ High memory usage for large data ❌ Latency — user waits until everything is loaded Example: Reading a full video file into memory before playing it. ━━━━━━━━━━━━━━━━━━━━━ 🌊 STREAM ━━━━━━━━━━━━━━━━━━━━━ A stream processes data CHUNK by CHUNK as it arrives. Think of it like drinking water directly from a tap — no waiting, no bucket. ✅ Low memory footprint ✅ Faster response time (start processing immediately) ✅ Ideal for large files & real-time data ❌ Slightly more complex to implement Example: Netflix streaming — you watch while it loads. ━━━━━━━━━━━━━━━━━━━━━ 🔑 KEY DIFFERENCES ━━━━━━━━━━━━━━━━━━━━━ | | Buffer | Stream | |---|---|---| | Data availability | All at once | Chunk by chunk | | Memory usage | High | Low | | Speed | Slower start | Faster start | | Best for | Small data | Large / real-time data | ━━━━━━━━━━━━━━━━━━━━━ 💡 Pro Tip: In Node.js, streams are first-class citizens. Use them when reading/writing large files, handling HTTP requests, or working with real-time pipelines! Which one do you use more in your day-to-day work? Drop a comment below! 👇 #NodeJS #JavaScript #WebDevelopment #Programming #SoftwareEngineering #BackendDevelopment #CodingTips #TechLearning #Developer #OpenSourceDev

𝗬𝗼𝘂’𝗿𝗲 𝗙𝗲𝘁𝗰𝗵𝗶𝗻𝗴 𝗗𝗮𝘁𝗮… 𝗕𝘂𝘁 𝗪𝗵𝘆 𝗔𝗿𝗲 𝗬𝗼𝘂 𝗥𝗲𝗯𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗘𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴? A lot of developers say: “I use React.” “I’m building with APIs.” But when you check their code… They’re manually handling everything: Loading states. Error states. Refetching. Caching. Every. Single. Time. 𝗧𝗵𝗮𝘁’𝘀 𝗪𝗵𝗲𝗿𝗲 𝗧𝗮𝗻𝗦𝘁𝗮𝗰𝗸 𝗤𝘂𝗲𝗿𝘆 𝗖𝗼𝗺𝗲𝘀 𝗜𝗻 It’s not just a library. It’s a 𝗱𝗮𝘁𝗮-𝗳𝗲𝘁𝗰𝗵𝗶𝗻𝗴 𝘀𝘆𝘀𝘁𝗲𝗺 built for modern React apps. 𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 (𝗪𝗶𝘁𝗵𝗼𝘂𝘁 𝗜𝘁) Fetching data in React manually looks simple… Until it’s not. You end up writing: • isLoading logic • try/catch error handling • retry mechanisms • caching logic • syncing server + UI state 𝗔𝗻𝗱 𝘆𝗼𝘂 𝗿𝗲𝗽𝗲𝗮𝘁 𝗶𝘁 𝗲𝘃𝗲𝗿𝘆𝘄𝗵𝗲𝗿𝗲. That’s not scalable. 𝗪𝗵𝗮𝘁 𝗧𝗮𝗻𝗦𝘁𝗮𝗰𝗸 𝗤𝘂𝗲𝗿𝘆 𝗗𝗼𝗲𝘀 It takes all that stress away. Out of the box, you get: 𝗟𝗼𝗮𝗱𝗶𝗻𝗴 𝘀𝘁𝗮𝘁𝗲𝘀 → no manual flags 𝗘𝗿𝗿𝗼𝗿 𝗵𝗮𝗻𝗱𝗹𝗶𝗻𝗴 → clean and predictable 𝗖𝗮𝗰𝗵𝗶𝗻𝗴 → data is stored and reused 𝗔𝘂𝘁𝗼 𝗿𝗲𝗳𝗲𝘁𝗰𝗵𝗶𝗻𝗴 → keeps data fresh 𝗦𝘆𝗻𝗰𝗵𝗿𝗼𝗻𝗶𝘇𝗲𝗱 𝘀𝘁𝗮𝘁𝗲 → UI always matches server All with a few lines. 𝗥𝗲𝗮𝗹-𝗟𝗶𝗳𝗲 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 You’re building a dashboard. Without TanStack Query: You write 30–50 lines just to fetch and manage one API. With it? You write a hook → and everything works. 𝗟𝗲𝘀𝘀 𝗰𝗼𝗱𝗲. 𝗙𝗲𝘄𝗲𝗿 𝗯𝘂𝗴𝘀. 𝗙𝗮𝘀𝘁𝗲𝗿 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁. 𝗪𝗵𝘆 𝗜𝘁’𝘀 𝗘𝘃𝗲𝗻 𝗠𝗼𝗿𝗲 𝗜𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁 𝗡𝗼𝘄 (𝗔𝗜 𝗘𝗥𝗔) With AI-powered apps… You’re constantly fetching data: -Chats -Suggestions -Predictions =Real-time updates If you handle all that manually? You’ll slow yourself down. 𝗧𝗮𝗻𝗦𝘁𝗮𝗰𝗸 𝗤𝘂𝗲𝗿𝘆 𝗯𝗲𝗰𝗼𝗺𝗲𝘀 𝗮 𝗻𝗲𝗰𝗲𝘀𝘀𝗶𝘁𝘆. Because in 2026… Speed isn’t just about performance. It’s about 𝗵𝗼𝘄 𝗳𝗮𝘀𝘁 𝘆𝗼𝘂 𝗯𝘂𝗶𝗹𝗱. Have you used TanStack Query yet? What was your experience? 👇 - Mustapha The Software Engineer #ReactJS #TanStackQuery #WebDevelopment #FrontendDevelopment #SoftwareEngineering #JavaScript #BuildInPublic #TechIn2026

I promised — and I delivered. Here's usePromise: a custom React hook I built that I genuinely believe should be in every developer's project from day one. Let me explain why. The problem nobody talks about openly: Every React developer has written this exact block of code hundreds of times mentioned in the image 👇 It works. It's familiar. And it's been silently violating the DRY principle across every codebase you've ever touched. usePromise replaces all of that with a single hook that handles: ✅ Loading, data, and error state — managed via useReducer to prevent async race conditions ✅ Real request cancellation via AbortController (not just ignoring the response — actually aborting the request) ✅ Data transformation at the configuration level with dataMapper ✅ Lifecycle callbacks — onSuccess, onError, onComplete, and isRequestAbortionComplete ✅ executeOnMount support — fire on render without a single useEffect in your component ✅ Full reset capability — return to initial state cleanly Why not just React Query? React Query is excellent for caching, deduplication, and large-scale data orchestration. But sometimes you want something you fully own — no black boxes, no magic, no dependency debates in code review. usePromise gives you that. It's a foundation you understand end-to-end and can extend however you need. Why should this be standard? SOLID principles tell us: don't repeat yourself. Async data fetching is the most repeated pattern in every React application in existence. The framework gives us the primitives — useReducer, useCallback, useEffect — but leaves the wiring entirely to us. Every team solves this problem. Most teams solve it inconsistently. This hook is the consistent answer. Three years in, and the thing I keep coming back to is this: the first few years of your career build the developer you'll be. The habits, the patterns, the defaults you reach for. Reach for clean ones. Full deep-dive article on Medium including the complete implementation, the Promise lifecycle explained from first principles, and an honest breakdown of trade-offs. This is the medium article for more clarity down below 👇 https://lnkd.in/gJWZhQXk #React #JavaScript #WebDevelopment #Frontend #OpenSource #ReactHooks #CleanCode

🚀 PUT vs PATCH — The REST API detail many developers misunderstand While reviewing backend code recently, I noticed something interesting. Many APIs expose PUT and PATCH endpoints… but treat them exactly the same. That’s a problem. Here’s the difference every backend developer should know: 🎯 Interview Definition PUT: An HTTP method used to replace the entire resource on the server with the data provided in the request payload. PATCH: An HTTP method used to partially update a resource, meaning only the specified fields are modified without affecting the rest of the resource. 🔵 PUT = Replace the entire resource Current user: { "name": "Bob", "email": "bob@gmail.com", "age": 25 } PUT request: PUT /users/1 { "name": "Bob Updated", "email": "bobupdated@gmail.com" } Result: { "name": "Bob Updated", "email": "bobupdated@gmail.com" } ⚠️ Notice something? The age field disappeared because PUT replaces the whole resource. PUT assumes the payload represents the complete new state. 🟡 PATCH = Partial update Current user: { "name": "Bob", "email": "bob@gmail.com", "age": 25 } PATCH request: PATCH /users/1 { "age": 26 } Result: { "name": "Bob", "email": "bob@gmail.com", "age": 26 } Only the age changed. Everything else stayed the same. 📌 Simple rule • PUT → Replace the resource • PATCH → Update part of the resource 💡 Why most modern APIs prefer PATCH ✔ Smaller payloads ✔ Lower risk of overwriting fields ✔ Better for frequent updates ✔ Works well with frontend forms 🔥 Backend tip When designing REST APIs: • Use PUT when the client sends the entire object • Use PATCH when updating specific fields Small API design decisions like this make systems cleaner, safer, and easier to maintain. #BackendDevelopment #REST #APIs #WebDevelopment #NodeJS #SoftwareEngineering #ProgrammingTips #CleanCode #W3Schools