After working on state, routing, and UI in earlier projects, I wanted to build something that depends on external data and real-time updates 🌍 Built a Weather App where you can search any city and get current conditions in a clean, responsive UI 🌦️ What this added for me 1. Working with API data instead of static state 2. Handling loading and error states properly 3. Keeping the UI clear even when data changes dynamically 📱 Stack: React, Vite, Tailwind CSS, Vercel 🔗 Live: https://lnkd.in/gZGcnUFS 💻 Code: https://lnkd.in/gasfj-vK Still building and improving, open to feedback or connections 👍 #React #JavaScript #FrontendDevelopment #WebDevelopment #BuildInPublic #LearningInPublic #API #Vite #TailwindCSS #DevCommunity #TechCareers #SoftwareDevelopment Error Makes Clever

Day 25 of my JavaScript journey 🚀 Built a Recipe Finder App using HTML, CSS, and JavaScript, powered by an external API. Features: 🍽️ Search recipes dynamically 🌐 Fetch data from TheMealDB API 📄 Display recipe details in real-time ✨ Interactive and user-friendly UI This project helped me understand how to work with APIs, handle asynchronous JavaScript, and build real-world applications. 🔗 Live Demo: https://lnkd.in/gSAAATzM 💻 GitHub Repo: https://lnkd.in/gBQmmBYJ Moving beyond basic projects and building applications that interact with real data. 💻 #JavaScript #WebDevelopment #FrontendDeveloper #100DaysOfCode #CodingJourney #API

#JourneyToTechJob – Day 5 🚀 #50DaysOfRevision Built a simple Color Picker Web App using JavaScript. Features: ✔️ Change background color with button clicks ✔️ Display selected color code ✔️ Dynamic UI updates using DOM manipulation What I learned: → Handling events in JavaScript → Updating UI dynamically → Writing reusable functions 🔗 Live Demo: https://lnkd.in/grH-tWFG Here’s a quick demo of the project 👇 #SoftwareDevelopment #JavaScript #FrontendDevelopment #WebDevelopment #Projects #50DaysOfCodeChallenge

Most React devs know when to use useLayoutEffect. Almost none can explain why it behaves differently. The answer lives inside the commit phase. React's update cycle has two big stages: render (reconcile, diff, no DOM writes) and commit (apply changes, run effects). Commit itself splits into 3 sub-phases: → Before Mutation — read DOM snapshots before anything changes → Mutation — insert, update, remove DOM nodes → Layout — refs attached, useLayoutEffect fires here, synchronously useEffect never runs in the Layout pass. During reconciliation, React builds an Effect List — fiber nodes tagged with pending work. Fibers marked HookLayout flush during the Layout sub-phase. Fibers marked HookPassive get handed to the scheduler and run after the browser paints. React docs put it directly: "React guarantees that the code inside useLayoutEffect and any state updates scheduled inside it will be processed before the browser repaints the screen." Classic case where this matters: tooltip positioning. With useEffect, users catch a flicker — the tooltip renders in the wrong spot, then jumps. With useLayoutEffect, both renders complete before any pixel changes on screen. The tradeoff: useLayoutEffect blocks paint. Use it only when you need to measure or mutate the DOM before the user sees the frame. Data fetching, subscriptions, analytics — those belong in useEffect. One gotcha: useLayoutEffect is a no-op in SSR. React will warn you. Guard with typeof window !== 'undefined' or default to useEffect in universal code. #frontend #reactjs #javascript #typescript #frontenddevelopment #softwareengineering #webdevelopment

🧠 Why Inline Functions Can Hurt React Performance This looks totally fine 👇 <button onClick={() => handleClick(id)}> Click </button> Works? ✅ Clean? ✅ Optimized? ❌ 🔍 What’s actually happening Every render creates a new function instance. () => handleClick(id) // new function every time So React sees: 👉 “This prop changed” Even if nothing else changed. ⚠️ The hidden impact When passed to child components: <Child onClick={() => handleClick(id)} /> 👉 Child re-renders every time 👉 React.memo becomes useless 👉 Performance drops in large apps ✅ Better approach const handleItemClick = useCallback(() => { handleClick(id); }, [id]); <Child onClick={handleItemClick} /> Now: ✔ Stable reference ✔ Fewer re-renders ✔ Better performance 🎯 Real Insight React doesn’t compare function logic. It compares references. 💥 Senior takeaway Most performance issues are not from big logic. They come from small patterns repeated many times. #ReactJS #FrontendDeveloper #JavaScript #WebDevelopment #Performance #SoftwareEngineering #CodingTips #TechCareers

🚀 React Re-rendering — Key Concepts Re-rendering is the core of how React keeps UI in sync with data. Without it, there would be no interactivity in our applications. Here are some important insights I've learned: 🔹 State updates are the primary trigger for re-renders 🔹 When a component re-renders, all its child components re-render by default 🔹 Even without props, components still re-render during the normal render cycle (without use of memoization). 🔹 Updating state in a hook triggers a re-render, even if that state isn’t directly used 🔹 In chained hooks, any state update will re-render the component using the top-level hook 🔹 “Moving state down” is a powerful pattern to reduce unnecessary re-renders in large applications #ReactJS #FrontendDevelopment #WebDevelopment #JavaScript #SoftwareEngineering #LearningInPublic

👀At first, it looked like just another basic project — but it actually helped me understand how real web apps work behind the scenes. 🔹 What I implemented: * Create tasks (POST) * View tasks (GET) * Update tasks (PUT) * Delete tasks (DELETE) 🔹 Tech used: * HTML, CSS, JavaScript * Express.js * Fetch API 💡 What I really learned: * How API calls work between frontend and backend * How data flows through requests and responses * Handling async operations using Promises * Building and structuring a basic REST API This project helped me move from just writing code → to actually understanding it. #WebDevelopment #FullStack #JavaScript #ExpressJS #LearningInPublic

A lot of people constantly ask me what React Hooks actually are, and the best way to think about Hooks and JavaScript concepts in general is to look at what problem they were trying to fix. For example, before React Hooks, people would create a Container Component and a Presentational Component. The Container Component would retrieve data, like making a fetch request, and then pass that data down to the Presentational Component, which was usually a pure function that returned some UI, like a div with styling, and accepted that data as props. This pattern helped create a standard for how data was retrieved in React and enforced separation of concerns, but it ended up being too boilerplate heavy for most people. So Hooks were introduced to let us hook into components directly, allowing us to load data as a side effect inside a function while still maintaining separation of concerns without needing extra components. #ReactJs #JavaScript #JavaScriptHooks

Some of the hardest React bugs I’ve seen weren’t actually inside React. They were happening somewhere in between. Between the event loop and the render cycle. You know the kind of bug. Everything looks correct. State updates are there. Handlers are wired properly. The logic makes sense. And yet… the UI shows stale data. Something flickers for a split second. It works fine locally, but breaks under real user interaction. Those are the bugs that make you question your sanity a bit. What’s really going on is this. We tend to think of React and JavaScript as one system. But they’re not. JavaScript runs your code - sync, promises, timeouts, all of that. React runs its own process - scheduling renders, batching updates, deciding when the UI actually updates. Most of the time, we blur that into one mental model. And most of the time it works. Until it doesn’t. That gap is where things get weird. You’ve probably seen versions of this: 🔹 You call setState and immediately get the old value 🔹 A setTimeout fires and uses stale data 🔹 A promise resolves and overwrites something newer 🔹 Everything works… until a user clicks fast enough Individually, none of this is surprising. But when it happens in a real app, it feels unpredictable. Because the problem isn’t what your code does. It’s when it runs. That’s why these bugs are so frustrating. You’re not debugging logic anymore. You’re debugging timing. The more I work on complex React apps, the more I notice this - a big part of senior frontend work isn’t just knowing hooks or patterns. It’s understanding how React’s rendering model interacts with the JavaScript runtime. Because once timing gets involved what looks correct can still be completely wrong. #reactjs #javascript #frontend #webdevelopment #softwareengineering #debugging #performance #typescript

Ever clicked two dropdowns and both stayed open at the same time? 😾 Looks unprofessional. Feels broken. Users hate it. Here is how I fixed it in React with just 2 lines : 👉 When Explore opens → force "Degree" dropdown to close onClick={() => {  setIsExploreMenuOpen(!isExploreMenuOpen);  setIsDegreeMenuOpen(false); // ← this one line does it }} 👉 When Degree opens → force "Explore" dropdown to close onClick={() => {  setIsDegreeMenuOpen(!isDegreeMenuOpen);  setIsExploreMenuOpen(false); // ← same idea }} The logic is simple: When you open something → explicitly close everything else. React does not do this automatically. You have to tell it exactly what to close. Small detail. Big difference in user experience. #react #nextjs #javascript #webdevelopment #tailwindcss #buildinpublic #frontenddevelopment