React Performance Optimization: Memo, Memoize, and Callback

I made React slower trying to optimize it. Wrapped everything in useMemo. Added useCallback everywhere. Felt productive. Performance got worse. Here's what I didn't understand about re-renders 👇 4 things that trigger a re-render: > State change > Prop change > Parent re-renders (even if YOUR props didn't change) > Context update That third one is responsible of unnecessary re-renders I've seen in real codebases. The fix isn't memorizing APIs. It's this order: 1. Profile first Open React DevTools Profiler. Find the actual problem. Takes 2 minutes. 2. Wrap the right components in React.memo Not all of them. Only components that are expensive AND receive stable props. 3. Stabilise your functions with useCallback Without it - new function reference every render --> child always re-renders. Doesn't matter if you have React.memo. 4. useMemo for heavy calculations only Not for "this array map looks expensive." Only when Profiler proves it. The rule I follow now: Don't optimise what you haven't measured. One change in the right place beats 10 changes in the wrong ones. What's the most unnecessary useMemo you've ever written? 😄 #React #JavaScript #Frontend #WebDev

There's a page in the React docs called "You Might Not Need an Effect." I'd say it's one of the most important pages in the entire React documentation. And most developers have either never read it or read it once and moved on. The whole idea comes down to one question: is your code syncing React with something React doesn't control? A WebSocket, a browser API, a third-party library? If yes, useEffect makes sense. If no, you're probably just adding extra renders and making your code harder to follow. Some patterns worth knowing: If you're deriving a value from props or state, just calculate it during render. No state, no effect needed. If you're responding to a user action like a click or form submit, put it in the event handler. The event handler already knows what happened. The effect doesn't. If you need to reset state when a prop changes, use the key prop. React will remount the component and reset everything automatically. If you're chaining effects where one sets state and triggers another, collapse all of it into a single event handler. React batches those updates into one render. If a child is fetching data just to pass it up to a parent, flip the flow. Let the parent fetch and pass it down. The rule the docs give is honestly the clearest way I've seen it put: if something runs because the user did something, it belongs in an event handler. If it runs because the component appeared on screen, it belongs in an effect. Every unnecessary useEffect is an extra render pass, an extra place for bugs to hide, and more code for the next person to untangle. Worth a read if you haven't: https://lnkd.in/gqUr7e_S How many effects in your current codebase do you think would actually pass that test? #ReactJS #Frontend #JavaScript #WebDevelopment #CleanCode

🚀 Starting a 10-part series on React things that make code harder than it needs to be. Not tutorials. Not “10 hooks you should know.” Just real patterns that show up in actual codebases and make simple work more annoying than it should be. Part 1: A lot of React problems are really state problems. Not React itself. Not JSX. Not even hooks most of the time. State living in too many places. Duplicated state. State doing jobs it was never supposed to do. That’s usually when an app starts feeling harder to reason about than it should. The more I work with React, the more I think good frontend code starts with good state decisions. If the state is messy, everything downstream gets harder: debugging feature work testing handoffs even basic collaboration Good React usually feels predictable. And predictable usually starts with state. What’s the most common state mistake you keep seeing? #React #ReactJS #StateManagement #FrontendEngineering #JavaScript #TypeScript #SoftwareEngineering

What Runs First in React? Most React developers know what useEffect, useMemo, and useCallback do individually. Far fewer know the exact order they execute in. And that gap causes bugs that are surprisingly difficult to trace. Here is the definitive execution order on first mount: -> Step 1: Rendering JSX React runs the function body of your component first. JSX is evaluated. console.log inside the return runs here. This is the render phase. -> Step 2: useMemo runs during render useMemo executes synchronously during the render phase, not after it. If you have an expensive computation wrapped in useMemo, it runs as part of building the component output. This is why useMemo can be used to compute values that are needed in the JSX itself. -> Step 3: useEffect runs after render After the component has rendered and the DOM has been updated, useEffect fires. It is intentionally deferred. This is where API calls, subscriptions, and side effects belong because they should not block the render. -> useCallback is different from all of them useCallback does not run during mounting. It stores a function reference. That function only executes when it is explicitly called. In the example on the right, increment only logs when you actually call increment(). The final order: Rendering JSX, then useMemo, then useEffect. Why this matters in practice: If you expect useEffect to run before useMemo, your state update will not be available when useMemo computes. If you expect useCallback to run automatically, your side effect will never fire. Getting the order wrong means working with stale data and writing code that behaves differently than you intended. Understanding execution order is not academic. It is the difference between components that behave predictably and ones that produce subtle timing bugs you spend hours debugging. Did you know the exact execution order before seeing this or did it surprise you? #React #ReactHooks #FrontendDevelopment #JavaScript #WebDevelopment #Developers

🚀 React Hooks: The Game-Changer You Didn’t Know You Needed Remember when managing state in React meant wrestling with class components, lifecycle methods, and endless this bindings? 😵💫 Then came Hooks — and everything changed. 💡 What are Hooks? Hooks let you “hook into” React features like state and lifecycle without writing a class. Clean, simple, and powerful. 🔥 Why developers love Hooks: ✔️ Less boilerplate, more clarity ✔️ Reusable logic with custom hooks ✔️ Easier to read and maintain ✔️ Functional components = cleaner architecture 🧠 The Essentials: useState → Manage state effortlessly useEffect → Handle side effects like a pro useContext → Avoid prop drilling nightmares useRef → Access DOM or persist values useMemo & useCallback → Optimize performance ⚡ Real Talk: Hooks didn’t just simplify React — they reshaped how we think about component design. Instead of splitting logic across lifecycle methods, you group related logic together. That’s not just cleaner… it’s smarter. 🎯 Pro Tip: Start creating your own custom hooks. That’s where the real magic happens — reusable, testable, and scalable logic across your app. 👨💻 Whether you're just starting with React or building production apps, mastering Hooks is no longer optional — it’s essential. 💬 What’s your favorite React Hook and why? Let’s discuss 👇 #ReactJS #WebDevelopment #Frontend #JavaScript #Coding #100DaysOfCode #Tech

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

⚛️ React Tip: When Should You Use useCallback? While working on React applications, one common performance issue developers face is unnecessary component re-renders. One hook that often comes up in this discussion is useCallback. But many developers (including me earlier) either overuse it or use it incorrectly. So here’s a simple way to understand it. 🔹 What does useCallback do? `useCallback` memoizes a function. This means React will reuse the same function instance unless its dependencies change. Example 👇 const handleClick = useCallback(() => { console.log("Button clicked"); }, []); Without `useCallback`, a new function is created every time the component re-renders. Most of the time this isn’t a problem. But it becomes important when passing functions to memoized child components. 🔹 Example scenario Imagine a parent component passing a function as a prop to a child component wrapped with `React.memo`. If the function reference changes on every render, the child component will also re-render unnecessarily. Using `useCallback` helps keep the function reference stable, preventing those extra renders. 🔹 When should you actually use it? ✅ When passing callbacks to memoized components ✅ When the function is a dependency in another hook ✅ When optimizing large component trees ⚠️ When NOT to use it: • For every function in your component • When there is no performance issue • Just because someone said it improves performance 💡 One important lesson I’ve learned: Optimization should be intentional, not automatic. React already does a lot of work under the hood. Use hooks like `useCallback` only when they actually solve a problem. Curious to hear from other developers 👇 Do you use `useCallback` often, or do you prefer optimizing only after profiling? #reactjs #frontenddevelopment #javascript #webdevelopment #reacthooks #softwareengineering #coding

⚡ A Simple React Optimization: Using React.memo While building React applications, one thing that can impact performance is unnecessary component re-renders. Sometimes a component re-renders even when its props haven’t changed. This is where React.memo can help. 🔹 What is React.memo? React.memo is a higher-order component that memoizes a component. It prevents re-rendering if the component’s props remain the same. Example 👇 const UserCard = React.memo(({ name }) => { return {name}; }); Now UserCard will only re-render when the name prop actually changes. 🔹 When should you use it? ✅ Components that receive the same props frequently ✅ Pure UI components ✅ Components inside large lists 🔹 When NOT to use it ⚠️ Very small components ⚠️ Components that always receive new props ⚠️ Without measuring performance impact 💡 One thing I’ve learned while working with React: Optimization should always be intentional and measured. Tools like React DevTools Profiler can help identify components that are re-rendering unnecessarily. Curious to hear from other developers 👇 Do you regularly use React.memo, or do you optimize only when performance issues appear? #reactjs #frontenddevelopment #javascript #webdevelopment #reactperformance #softwareengineering #coding

Most React performance problems I've seen are not caused by bad code; they're caused by not understanding how React decides to re-render. A lot of developers reach straight for `useMemo` and `useCallback` the moment something feels slow. But wrapping everything in memoisation without measuring first is just noise. It adds cognitive overhead and, in some cases, can actually make things worse by holding references in memory longer than necessary. What genuinely moves the needle: - Colocating state as close as possible to where it's used, so unrelated components never re-render in the first place - Keeping context values stable; passing a new object literal into a Provider on every render is one of the most common silent performance killers - Splitting large page components into smaller, well-bounded units so React's reconciler has less to evaluate - Using the React DevTools Profiler before writing a single line of optimisation code With Next.js, there's an additional layer to think about: the boundary between Server Components and Client Components. Moving data-heavy, non-interactive parts of your UI to the server can reduce your JavaScript bundle size dramatically; that tends to do more for perceived performance than any client-side tweak. Performance work should always start with measurement, not assumption. What's the most surprising performance issue you've uncovered in a React project? #React #NextJS #FrontendDevelopment #WebPerformance