<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Bhawana Shanker on Medium]]></title>
        <description><![CDATA[Stories by Bhawana Shanker on Medium]]></description>
        <link>https://medium.com/@developershanker95?source=rss-c35562a980bb------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*L2VT67sXu1IdNCQ46Hvy4Q.png</url>
            <title>Stories by Bhawana Shanker on Medium</title>
            <link>https://medium.com/@developershanker95?source=rss-c35562a980bb------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 10:24:52 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@developershanker95/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your React Native Heap Snapshot Is Lying to You]]></title>
            <link>https://medium.com/@developershanker95/your-react-native-heap-snapshot-is-lying-to-you-2298f05a5f52?source=rss-c35562a980bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/2298f05a5f52</guid>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[memory-leak]]></category>
            <category><![CDATA[optimisation]]></category>
            <dc:creator><![CDATA[Bhawana Shanker]]></dc:creator>
            <pubDate>Tue, 23 Jun 2026 08:53:52 GMT</pubDate>
            <atom:updated>2026-06-23T08:53:52.270Z</atom:updated>
            <content:encoded><![CDATA[<p>A field guide to memory leaks — from the side of the heap your profiler can’t see.</p><p>Here’s a failure mode I’ve watched play out more than once.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aqoacImrAi5_RJw9QF_Gcw.png" /><figcaption>courtesy: Google Gemini</figcaption></figure><p>A build passes every memory check you throw at it. Heap snapshots in React Native DevTools come back flat. No retained component trees, no growing object counts, nothing obviously wrong. You ship it. Then the crash dashboard starts filling with OutOfMemoryError from low-end Android devices, and you stare at a profiler that insists everything is fine.</p><p>It’s fine. It’s just looking at the wrong heap.</p><p>I went quiet for a few weeks and spent a chunk of that time going properly deep on memory in React Native — not the “remember to remove your listeners” version everyone already knows, but the model underneath it. This is the writeup. It’s long on purpose. If you only take one idea away, make it the one in the second section, because it’s the one that explains the crashes your tooling can’t.</p><h3>First, unlearn “forgetting to free”</h3><p>If you came to JavaScript from a manually-managed language, your instinct says a leak is memory you forgot to release. Drop that instinct here. Hermes — the engine React Native runs by default — will <em>always</em> reclaim anything it can’t reach. It is never going to forget.</p><p>So a leak in a garbage-collected runtime isn’t forgotten cleanup. It’s <strong>unintentional reachability</strong>: you’re done with an object, but something still holds a reference to it, so the collector is <em>correct</em> to keep it alive. You didn’t fool the GC. You quietly told it the object still matters.</p><p>That reframe changes where you look. The question is never “what did I forget to free.” It’s always:</p><blockquote><strong>What long-lived thing is still holding a reference to this short-lived thing?</strong></blockquote><p>And the long-lived holder is almost always one of a small set: a module-level singleton, a still-mounted component’s closure, a native event emitter, a timer registered with the host, or an in-flight async callback. Every leak you’ll ever chase reduces to finding which of those is still pointing at something it should have let go of.</p><pre>/ LEAK — a long-lived holder keeps the object reachable forever<br>const seen = [];<br>seen.push(bigObject);        // nothing removes it → the GC can&#39;t collect it<br><br>// HEALTHY — the reference is local; it dies when the function returns<br>function use() {<br>  const tmp = bigObject;     // tmp is unreachable the moment use() returns<br>}</pre><p>No free() anywhere. The only difference between those two is <em>who still holds a reference</em> once you’re done. That is the entire definition of a leak.</p><h3>The part nobody tells you: there are two heaps</h3><p>This is the idea that reframes everything, and it’s the one most React Native leak articles skip entirely.</p><p>Your JavaScript objects — component state, closures, Redux slices, strings — live in the <strong>Hermes GC heap</strong>. It’s managed by Hades, a mostly-concurrent generational collector that does most of its work on a background thread while your JS keeps running. Pure-JS leaks show up here, and DevTools heap snapshots can see them.</p><p>But a real React Native app holds a second, much larger pool of memory the GC heap barely knows about: the <strong>native heap</strong>. Bitmaps. WebView instances. Video and camera buffers. The C++ allocations behind every JSI native module. And here’s the trap — from the GC’s point of view, a native-backed object is a <em>tiny JavaScript handle</em>. Hermes sees a few bytes. It never feels the megabytes that handle is keeping alive in C++, so it never experiences memory pressure from them, and it never collects them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/848/1*WKxzV4aI_JzbTJhLpJDdBA.png" /><figcaption>Snapshot only sees the top half</figcaption></figure><p>The consequence is the bug I opened with. Your JS heap snapshot can be flat as a board while the device’s actual resident memory climbs until Android kills the process. The leak is completely real. It just isn’t in the heap you’re profiling.</p><pre>// LEAK — JS holds a small handle; the native side holds the real megabytes<br>const cache = new Map();<br>cache.set(uri, await Image.prefetch(uri));   // grows forever → native RAM climbs,<br>                                             // while the JS snapshot barely moves<br><br>// FIX — bound it, and release on the way out<br>if (cache.size &gt; 50) cache.delete(cache.keys().next().value);</pre><p>This single fact is why, later in this piece, the catalog of leaks is split into two columns. One column is what DevTools can catch. The other column needs Android Studio Profiler or Xcode Instruments, because DevTools is structurally incapable of seeing it. If you remember which heap a leak lives in, you already know which tool will find it.</p><h3>The one shape behind most JS-side leaks</h3><p>Before the full catalog, internalize the single mechanism that produces the overwhelming majority of JavaScript-heap leaks. Once you see it, you see it everywhere.</p><p>On mount, you hand a callback to something that outlives your screen — a native event emitter, a timer, a subscription, a socket. That callback closes over your component, which means it transitively holds your component’s entire state tree. On unmount, the UI removes your screen visually. But if you never took the callback back, the long-lived thing still holds it, your component is still reachable, and nothing gets collected.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/888/1*kCpXpYlBM-vxkR-sMccnRA.png" /><figcaption>mount — unmount situations</figcaption></figure><p>The fix is always the teardown you return from the effect. This is so consistent it’s almost not worth memorising the individual cases — just the rule.</p><pre>/ LEAK — registered on mount, never removed<br>useEffect(() =&gt; {<br>  const sub = BackHandler.addEventListener(&quot;hardwareBackPress&quot;, onBack);<br>}, []);                          // no return → the listener outlives the screen<br><br>// FIX — return the teardown<br>useEffect(() =&gt; {<br>  const sub = BackHandler.addEventListener(&quot;hardwareBackPress&quot;, onBack);<br>  return () =&gt; sub?.remove();    // the reference is cut on unmount<br>}, [onBack]);</pre><p>Those two blocks are byte-for-byte identical except for one line. That return <em>is</em> the difference between a clean unmount and a retained one. I’ve shipped this exact bug — a BackHandler listener on a list screen that captured the first render’s state and quietly outlived every navigation away from it. It manifested first as a <em>stale data</em> bug, which is the tell I’ll come back to: the same un-removed listener that corrupts your data is also the one retaining your memory.</p><h3>The field guide: every leak type, split by heap</h3><p>Eight families. Two columns. Left side lives in the JS heap, so DevTools can catch it. Right side lives in the native heap, so you need native profilers. Each one gets the leaking line and the one-line fix.</p><h3>JS-heap leaks (DevTools can see these)</h3><p><strong>1. Uncleaned listeners and subscriptions.</strong> The canonical case from the section above, and its whole family: AppState, Dimensions, Keyboard, NativeEventEmitter, navigation focus/blur listeners. Anything you add, you owe a remove.</p><pre>const sub = emitter.addListener(&quot;evt&quot;, cb);<br>return () =&gt; sub?.remove();      // ← the line people forget</pre><p><strong>2. Timers and intervals.</strong> The moment you poll something on an interval — heart-rate zones, a sync status, a countdown — an uncleared setInterval is a permanent root. The host holds your callback forever, and the callback holds everything it closed over.</p><pre>const id = setInterval(poll, 5000);<br>return () =&gt; clearInterval(id);</pre><p><strong>3. In-flight async resolving into an unmounted tree.</strong> This one matters more as apps get streamier. When you stream model output over SSE, or fire a fetch and await it, the pending handler holds a closure over the component that started it. Navigate away mid-stream and that closure keeps the dead screen reachable until the request settles — and then tries to setState on nothing. AbortController is the clean teardown.</p><pre>const ctrl = new AbortController();<br>fetchAdvice({ signal: ctrl.signal });<br>return () =&gt; ctrl?.abort();</pre><p><strong>4. Stale closures that pin scope.</strong> You probably know stale closures as a <em>correctness</em> bug — a callback captured once that keeps seeing the first render’s values. The memory side is the same bug wearing a different hat. If that captured-once callback is held by a long-lived subscriber, it keeps that entire captured scope alive indefinitely. One bug, two symptoms: wrong data <em>and</em> retained data. When you fix the dependency array, you’re often fixing a leak you didn’t know you had.</p><pre>const onBack = () =&gt; goTo(step);   // captures the first `step` forever<br>// fix: add [step] to deps, or read the latest value from a ref</pre><p><strong>5. Unbounded stores and caches.</strong> Not every leak involves a listener. A Redux or Zustand slice that only ever grows, or a module-level Map you treat as a cache but never evict from, has identical symptoms. Conversation memory in an AI feature is the obvious modern offender: append every turn forever and you’ve built a leak with no subscription in sight.</p><pre>messages.push(turn);             // grows without bound<br>messages = messages.slice(-50);  // keep the last N instead</pre><h3>Native-heap leaks (you need Android Studio Profiler / Xcode Instruments)</h3><p><strong>6. Lists, images, and bitmaps.</strong> Large base64 strings parked in state, or a FlatList whose renderItem closes over heavy objects, retain on the native side. This is the textbook “flat JS snapshot, climbing RSS” leak. The fix is usually to stop holding decoded pixels in JavaScript at all.</p><pre>setPhotos(p =&gt; [...p, hugeBase64]);   // heavy bytes living in JS state<br>// store the uri and let the native layer decode lazily:<br>&lt;Image source={{ uri }} /&gt;</pre><p><strong>7. WebView and native bridges.</strong> A WebView carries an entire second runtime — its own JS context and DOM. If the React component that owns it doesn’t fully tear down, or a native module retains a callback back into it, you keep that whole runtime alive. Modal WebView flows — a payment bridge, an identity step, an embedded checkout — are repeat offenders precisely because they mount and unmount over and over. I’ve built a multi-stage WebView-to-native payment bridge; the memory discipline there matters as much as the message-passing does.</p><pre>// don&#39;t keep it mounted &quot;for speed&quot;<br>{visible ? &lt;WebView source={{ uri }} /&gt; : null}</pre><p><strong>8. JSI HostObjects and native modules.</strong> The deepest layer. Beyond the GC-invisibility problem from the two-heap section, the New Architecture adds a finalization hazard: because Hades is concurrent, it can destroy a JS object on a <em>different thread</em> than the one that created it. Libraries holding thread-local native resources can crash on that, producing memory errors on unmount that look impossible from the JS side. You probably won’t author HostObjects, but you <em>consume</em> libraries that do — Skia, Reanimated, vision-camera, MMKV — so this is the explanation for otherwise-baffling native crashes.</p><pre>// the GC won&#39;t free the native side for you<br>return () =&gt; skImage?.dispose?.();   // call the library&#39;s explicit release</pre><p>Notice the pattern across the entire JS column: the fix is almost always <em>a </em><em>return from </em><em>useEffect</em>. Different verb each time — remove, clearInterval, abort, dispose — same teardown discipline.</p><h3>Finding them: the 2026 toolchain</h3><p>The tooling story has fully turned over in the last couple of years, and a lot of older articles will send you to tools that no longer ship. Here’s the current reality.</p><p><strong>React Native DevTools</strong> replaced Flipper as the default debugger starting with React Native 0.76. It’s built on the Chrome DevTools Protocol and talks directly to the Hermes runtime, so attaching it doesn’t change how your app behaves. You open it by pressing j in the Metro terminal. Note that connecting through chrome://inspect is no longer supported, and React Native 0.83 added a proper Performance Panel with flame-chart profiling.</p><p>The core technique for JS-heap leaks is <strong>snapshot diffing</strong>, and the discipline is what makes it work:</p><ol><li>Take a heap snapshot.</li><li>Perform a repeatable action that should fully clean up — open a heavy screen and close it.</li><li>Repeat that action about five times.</li><li>Take a second snapshot and filter to what was allocated between the two.</li></ol><p>If components, players, or large buffers from a screen that’s been closed five times are still present, that’s your leak, and the retainer chain tells you who’s holding them. DevTools also has an allocation-timeline view if you’d rather watch memory as a graph over time.</p><p>For the native heap — the half DevTools can’t show you — reach for <strong>Android Studio Profiler</strong> (bitmaps, WebView, video, native-module memory on Android) and <strong>Xcode Instruments</strong> (leaks, allocations, and retain cycles on iOS). <strong>LeakCanary</strong> remains the standard for automatic Android leak detection, and <strong>react-native-release-profiler</strong> handles production CPU profiling with Hermes.</p><p>One discipline point outweighs tool choice: <strong>profile a release-like build, not a dev build.</strong> Dev-mode overhead hides the real shape of the problem. And judge by the <em>trend</em> across a repeated flow — does memory plateau or keep climbing — not by any single absolute number.</p><h3>The one rule that prevents most of this</h3><p>Nearly every JS-side family in the catalog collapses into a single sentence:</p><blockquote>Most leaks come from code that starts something inside an effect and never stops it when the component unmounts.</blockquote><p>Every addEventListener, setInterval, subscription, socket, and fetch you start in a useEffect owes a matching teardown in that effect’s return. Get that reflex automatic and you’ve closed off most of the JavaScript column.</p><p>The rest is a short list of habits. Bound your caches and stores instead of letting them grow forever. Reach for WeakRef / WeakMap when you’re holding incidental references you’d be happy for the GC to drop. Clear user-scoped state on logout and heavy screen-scoped state on the way out. And don’t capture large objects in closures that outlive the render that created them.</p><h3>Why React Native makes all of this sharper</h3><p>Three structural reasons, worth holding in your head:</p><p>There’s <strong>one JS thread and one event loop</strong>, so a retained closure isn’t only a memory cost — anything that clogs the loop blocks touches, timers, and animations too.</p><p>There are <strong>two heaps</strong>, so your profiler can read clean while the device fills up. You have to know which heap to point a tool at, every time.</p><p>And the New Architecture’s <strong>concurrent finalisation</strong> changes <em>when</em> and <em>on which thread</em> native cleanup runs, which can turn teardown code that worked fine for years into a race.</p><p>None of this is exotic once you have the model. A leak is a reference you didn’t mean to keep. There are two places that reference can live. And almost every fix is the cleanup you return from an effect. Hold those three ideas and the crash dashboard stops being a mystery.</p><p>That’s what I spent the quiet weeks on. Back to building.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2298f05a5f52" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From “Just a Trend” to “Use It Unless You Have a Reason Not To”]]></title>
            <link>https://medium.com/@developershanker95/from-just-a-trend-to-use-it-unless-you-have-a-reason-not-to-98dbea8bf82a?source=rss-c35562a980bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/98dbea8bf82a</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[mobile-development]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[expo]]></category>
            <dc:creator><![CDATA[Bhawana Shanker]]></dc:creator>
            <pubDate>Thu, 04 Jun 2026 15:36:52 GMT</pubDate>
            <atom:updated>2026-06-04T15:36:52.548Z</atom:updated>
            <content:encoded><![CDATA[<h3>The real story of Expo: from a developer who spent years avoiding it</h3><p>Been seeing Expo show up more in job descriptions lately.</p><p>Interesting. Because not long ago, the React Native community had a pretty clear consensus: Expo is for beginners, MVPs, and side projects. If you’re building something serious, you go bare RN.</p><p>So I went digging. Why is Expo back in the conversation? What actually changed? And was the skepticism ever even valid?</p><p>Here’s the honest answer, backed by what actually happened in the ecosystem, and what it means for you right now.</p><h3>The early days: attractive, but avoided for good reason</h3><p>Expo showed up promising something genuinely exciting.</p><p>Ship faster. Update your app over the air. Skip the App Store review cycle entirely. For developers coming from web, it felt almost magical.</p><p>But production teams stayed away. And honestly? They were right to.</p><p>The problem was something called the <strong>eject</strong>. The moment your app needed anything beyond Expo’s managed SDK: a custom payment SDK, Bluetooth, biometrics, health data APIs: you had to eject out of the managed workflow entirely.</p><p>And ejecting was a one-way door.</p><p>You lost your Expo modules. You inherited a pile of native configs you hadn’t set up yourself. And you were suddenly maintaining a bare React Native project anyway: except messier, because you hadn’t started that way.</p><p>On top of that, around 2020:</p><ul><li>No custom native modules in managed workflow</li><li>Larger app binary sizes: even a Hello World was ~25MB</li><li>Push notifications locked to Expo’s own notification service only</li><li>SDK version lagged behind React Native releases</li><li>Not enterprise-friendly by any meaningful measure</li></ul><p>So companies treated Expo as a trend. Something for prototypes and hackathons. The serious work happened in bare RN, where you had full control over ios/ and android/ directories, Gradle configs, Xcode entitlements, and native module linking.</p><p>For years, that was the correct call.</p><h3>What actually changed: the timeline nobody talks about</h3><p>This is the part most developers miss. Expo didn’t just get popular again. It rebuilt itself from the ground up between 2020 and 2022. And the changes were architectural, not cosmetic.</p><h3>December 2020: EAS Build launches</h3><p>Cloud-based builds that work with <em>any</em> React Native app. Not just managed Expo projects.</p><p>For the first time, you didn’t have to choose between Expo’s tooling and native flexibility. You could have both.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/481/1*aL2kpb1dWz9ykFC327S0Yg.png" /></figure><h3>April 2021: expo pre-build replaces eject</h3><p>The painful, permanent eject model was replaced with a command that <em>continuously generates</em> native projects from your config. You could modify it, regenerate it, and go back. The one-way door was gone.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/396/1*NLE_5uF__K-cZOyKbOE4Pw.png" /></figure><h3>August 2022 : expo eject fully deprecated</h3><p>Config plugins meant any native library could be wired into an Expo project without writing a single line of native Java, Kotlin, Swift, or Objective-C. The biggest blocker the entire community had cited for years custom native modules: was effectively solved.</p><h3>2023–2024 : EAS Update matures</h3><p>Over-the-air updates at scale became reliable. Teams started shipping UI fixes and logic changes without App Store reviews. Not as a workaround, as standard workflow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/1*A4sfPsrdh4O5lNHuBFTzHA.png" /></figure><h3>2025: New Architecture support</h3><p>All expo-* packages fully supported the New Architecture, including bridgeless mode. Better performance, JSI-based native modules, Fabric renderer, the future of React Native, available in Expo first.</p><h3>2026 : Enterprise adoption</h3><p>83% of Expo SDK 54 projects on EAS Build now run on the New Architecture. SDK 55 ships with it enabled by default, no toggle, no legacy fallback, no opt-in required.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/691/1*_ophyIPfSYnQY__LPnfnNw.png" /></figure><p>The tool that was “not enterprise friendly” in 2020 is now the toolchain Meta, Microsoft, and Shopify build on.</p><h3>My honest take, coming from years in bare RN production</h3><p>I spent years doing bare React Native in production.</p><p>Custom payment bridges wired through WebViews. Native health SDKs on both platforms. Enterprise analytics integrations with manual linking. ProGuard configs. Gradle customisations. Xcode entitlements and provisioning profiles managed by hand.</p><p>Stuff the managed Expo workflow simply couldn’t touch at the time.</p><p>That foundation mattered. And it still does.</p><p>Understanding what’s happening at the native layer, why a module link fails, what a bridged call actually does under the hood, how Hermes handles closures differently in release builds vs debug, that knowledge doesn’t become irrelevant just because Expo abstracts it away.</p><p>If anything, it becomes <em>more</em> valuable. Because when something breaks beneath the abstraction layer, you’re the person who knows where to look.</p><p>But here’s what exploring Expo recently made clear to me:</p><p>The abstraction isn’t hiding complexity to make you dumber. It’s hiding complexity so your team can focus on the actual product.</p><p>OTA updates without App Store review. Cloud builds without maintaining local Xcode and Gradle environments. Less DevOps overhead per engineer. Reproducible builds across the entire team. More shipping, less configuring.</p><p>For a lean startup iterating fast, that trade-off is obvious. For a solo developer building a side project, it’s a no-brainer. Even for larger teams, the question is no longer <em>whether</em> to use Expo, it’s <em>how much</em> of the Expo ecosystem makes sense for your context.</p><h3>The question the industry stopped asking</h3><p>For years, the React Native community debated: <strong>Expo OR bare React Native?</strong></p><p>In 2026, that question doesn’t reflect how the ecosystem actually works anymore.</p><p>Companies no longer ask “Expo or React Native?” They ask “Expo + React Native, where on that spectrum does our product live?”</p><p>The new default flow looks like this:</p><ol><li><strong>Start with Expo</strong> — ship fast, get the best developer experience the ecosystem offers</li><li><strong>Need custom native code?</strong> — add it via a config plugin or the Expo Modules API</li><li><strong>Stay in the Expo ecosystem</strong> — keep EAS Build, keep OTA updates, keep the tooling</li></ol><p>As the React Native community put it in 2026: <em>“Use Expo unless you have a strong reason not to.”</em></p><p>That strong reason still exists. Legacy brownfield apps with existing native codebases. Hardware-heavy apps needing deep SDK integrations that config plugins don’t yet cover. Enterprise contexts with specific build pipeline requirements.</p><p>But it’s a reason you need to justify now — not the default assumption.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/753/1*Urj_eTCTD4fnon9Vf0uXrg.png" /></figure><h3>What this means if you’re a React Native developer right now</h3><p><strong>If you learned on bare RN</strong> — your knowledge isn’t wasted. It’s your competitive edge. You understand what Expo is abstracting and why. That makes you the engineer who can debug what others can’t when something breaks at the native layer.</p><p><strong>If you’ve been ignoring Expo based on opinions from 2019 or 2020</strong> : the tool you dismissed was rebuilt while you weren’t watching. Worth a fresh look.</p><p><strong>If you’re just starting out : </strong>learn bare RN fundamentals first. Understand Info.plist, build.gradle, native module linking, how the JS bridge works. Then use Expo. You&#39;ll appreciate what it&#39;s doing for you instead of being caught off guard when it can&#39;t do something.</p><p>The developers who thrive in this ecosystem are the ones who can move fluidly across both worlds, who understand the native layer well enough to know when Expo’s abstraction is sufficient, and when it isn’t.</p><p>Expo isn’t simplifying React Native anymore.</p><p>It’s defining it.</p><p><em>What’s your team using in 2026, Expo, bare RN, or somewhere in between? Drop a comment. I’d genuinely like to know how the decision played out.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98dbea8bf82a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Integrating Health Data in React Native: A Deep Dive into HealthKit and Health Connect]]></title>
            <link>https://medium.com/@developershanker95/integrating-health-data-in-react-native-a-deep-dive-into-healthkit-and-health-connect-3a35b80efe56?source=rss-c35562a980bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a35b80efe56</guid>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[health-connect]]></category>
            <category><![CDATA[healthtech]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <dc:creator><![CDATA[Bhawana Shanker]]></dc:creator>
            <pubDate>Thu, 21 May 2026 07:00:51 GMT</pubDate>
            <atom:updated>2026-05-21T07:00:51.286Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Two platforms, two completely different health APIs, and three bugs that taught us more than the docs ever could.</em></p><h3>Why Health Data?</h3><p>When building a wellness app, showing the user their own data is the fastest path to trust. Steps walked, sleep tracked, heart rate measured — this data already exists on their phone. You just need to ask for it correctly.</p><p>On paper, this sounds simple. In practice, you are dealing with two completely separate ecosystems — Apple HealthKit on iOS and Google Health Connect on Android — each with its own data model, permission flow, and failure mode. This article covers exactly what we built, what broke, and how we fixed it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CTFGJ_QOkbX4nhtbEP8WNQ.jpeg" /></figure><h3>The Architecture Decision: One Façade, Two Implementations</h3><p>The first decision was to never let the rest of the app care about which platform it is running on. We wrote a single service file (healthService.ts) that exposes two functions:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W3r_bUMRWT6852bkt4XoLg.png" /></figure><p>The HealthData interface is flat and platform-agnostic:</p><pre>export interface HealthData {<br>  steps?: number;<br>  weight?: number;   // kg<br>  height?: number;   // cm<br>  heartRate?: number; // bpm<br>  sleep?: number;  // hours<br>}</pre><p>Inside the service, Platform.OS routes to the correct implementation. The caller never knows which health API ran. This is the single best decision we made — it meant that every bug we fixed in one platform did not require touching the rest of the app.</p><h3>iOS: HealthKit via react-native-health</h3><p>Library: react-native-health v1.19.0</p><p>HealthKit is the older and more mature of the two. Apple introduced it in 2014, and the community library has had years to stabilise.</p><p>Initialisation is callback-based (not Promise-native), so we wrapped it:</p><pre>function initIOS(): Promise&lt;boolean&gt; {<br>  return new Promise(resolve =&gt; {<br>    const AppleHealthKit = require(&#39;react-native-health&#39;);<br>    AppleHealthKit.initHealthKit(<br>      {<br>        permissions: {<br>          read: [<br>            Permissions.StepCount,<br>            Permissions.HeartRate,<br>            Permissions.SleepAnalysis,<br>            Permissions.Weight,<br>            Permissions.Height,<br>          ],<br>          write: [],<br>        },<br>      },<br>      (err: string) =&gt; resolve(!err),<br>    );<br>  });<br>}</pre><p>Permissions in HealthKit are declared upfront as a single list. If the user denies one, the others still work. The app never knows which specific permissions were denied — HealthKit intentionally hides this for privacy.</p><p>Reading data is also callback-based throughout, so we wrote a generic promisify helper:</p><pre>function iosRead&lt;T&gt;(fn: Function, opts: object): Promise&lt;T | null&gt; {<br>  return new Promise(resolve =&gt; {<br>    fn(opts, (err: string, res: T) =&gt; resolve(err ? null : res));<br>  });<br>}</pre><p>Each data type then becomes a clean one-liner:</p><pre>const steps = await iosRead&lt;{ value: number }&gt;(<br>  AppleHealthKit.getStepCount.bind(AppleHealthKit),<br>  { date: startOfDay.toISOString() },<br>);</pre><blockquote><strong>What HealthKit handles well</strong>: <em>Deduplication</em>. If the user has Apple Watch, iPhone, and a third-party app all writing steps, HealthKit’s OS-level merging ensures you get one clean number. We did not have to write any deduplication logic.</blockquote><h3>Android: Health Connect via react-native-health-connect</h3><p>Library: react-native-health-connect v3.5.0</p><p>Health Connect is Google’s answer to HealthKit, launched in 2022 and built into Android 14+ (available as a standalone APK on Android 9–13). It is a central data hub — apps write to it, apps read from it, and the OS manages permissions in one place.</p><p>Initialisation has an extra step HealthKit does not: you must check whether the SDK itself is available before calling anything else.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/1*rNc8PXQdrdz0D3ShZy2oyA.png" /></figure><p>On Android 9–13 devices that do not have Health Connect installed, this check saves you from a crash. Older HealthKit never had this problem because it ships with iOS.</p><p>Permission model is per-record-type, not a single list:</p><pre>await requestPermission([<br>  { accessType: &#39;read&#39;, recordType: &#39;Steps&#39; },<br>  { accessType: &#39;read&#39;, recordType: &#39;HeartRate&#39; },<br>  { accessType: &#39;read&#39;, recordType: &#39;SleepSession&#39; },<br>  { accessType: &#39;read&#39;, recordType: &#39;Weight&#39; },<br>  { accessType: &#39;read&#39;, recordType: &#39;Height&#39; },<br>]);</pre><p>Reading data is Promise-native and uses two methods: aggregateRecord for totals (steps, heart rate count, sleep duration) and readRecords for raw entries (weight, height):</p><pre>const agg = await aggregateRecord({<br>  recordType: &#39;Steps&#39;,<br>  timeRangeFilter: {<br>    operator: &#39;between&#39;,<br>    startTime: startOfDay,<br>    endTime: now,<br>  },<br>});<br>result.steps = agg.COUNT_TOTAL;</pre><h3>Challenge 1: The Timezone Bug</h3><p><strong><em>Symptom</em></strong>: Users in IST (UTC+5:30) saw steps starting from 6:30 PM the previous day instead of midnight. The step count was correct for ~18.5 hours, not the current day.</p><p><strong><em>Root cause</em></strong>: JavaScript’s .toISOString() always returns UTC. When a user in IST sets startOfDay to local midnight (00:00:00), and then calls .toISOString(), JavaScript converts it to UTC — which is 18:30:00 of the <em>previous</em> day.</p><pre>// What we wrote<br>const startOfDay = new Date();<br>startOfDay.setHours(0, 0, 0, 0);<br>startOfDay.toISOString(); // &quot;2026-05-19T18:30:00.000Z&quot; ← wrong for IST users</pre><p>Health Connect received that UTC string and correctly fetched data from 6:30 PM the day before. The library was doing exactly what we asked. We were asking the wrong thing.</p><p><strong><em>Solution</em></strong>: Replace all .toISOString() calls with dayjs().format(), which produces an ISO 8601 string that <em>includes the local timezone offset</em>:</p><pre>import dayjs from &#39;dayjs&#39;;</pre><pre>const startOfDay = dayjs().startOf(&#39;day&#39;).format();<br>// &quot;2026-05-20T00:00:00+05:30&quot; ← correct</pre><p>Health Connect receives the offset and interprets it as the user’s actual local midnight.</p><p><strong><em>Verdict</em></strong>: This is a silent bug. It will not crash, throw an error, or show up in any log. The only way to catch it is to notice that your step count feels off. If your app queries health data with date ranges, always use a timezone-aware date library. Never trust .toISOString() for local-time queries.</p><h3>Challenge 2: Inflated Step Count on Android</h3><p><strong><em>Symptom</em></strong>: The app showed ~26,000 steps when Samsung Health showed ~8,600 for the same day.</p><p><strong><em>Root cause</em></strong>: Health Connect is a data hub, not a tracker. It does not generate data — it collects it from whatever apps the user has installed and granted write access. On the test device, three sources were writing steps:</p><ul><li>android — the phone&#39;s built-in pedometer</li><li>com.google.android.apps.fitness — Google Fit</li><li>com.sec.android.app.shealth — Samsung Health</li></ul><p>When we called aggregateRecord without any source filter, Health Connect summed all three. Three apps, one pedometer, one step count multiplied by three.</p><p>What we tried first: Filter by source using dataOriginFilter:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/926/1*H_ylPZq6O0JKAdKD_9tvqQ.png" /></figure><p>This worked on the specific test device but is the wrong approach for a production app. Not every user has Samsung Health. Hardcoding a source filter means your app breaks silently on any device that does not have that exact app installed.</p><p><strong><em>The real solution</em></strong>: Health Connect has a built-in priority system. In the Health Connect app, users can go to App permissions → Data preferences and set which app they trust most for each data type. When a priority is set, aggregateRecord respects it automatically.</p><p>Instead of filtering in code, we added a UI hint on the Home screen for Android users:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*D0lJ0p3nDL1cifTT98AfrQ.jpeg" /></figure><p>Tapping the hint opens the Health Connect settings page directly via a deep link.</p><p><strong><em>Verdict</em></strong>: This is an Android-only problem. iOS HealthKit deduplicates at the OS level — you never see this with HealthKit. On Android, the dataOriginFilter approach works only if you know exactly which app the user has installed, which you cannot assume. The correct approach is to trust the system&#39;s priority mechanism and educate the user.</p><p>OS vs Android: Side-by-Side</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H1I9lHDUdvDvUteXRmPzrw.png" /></figure><h3>The Single-Interface Pattern</h3><p>The most maintainable outcome of this work is that the app’s UI layer calls two functions and never touches either library directly:</p><pre>const ok = await initHealthService();   // handles both platforms<br>const data = await readHealthData();    // returns HealthData regardless of OS</pre><p>When Apple or Google changes their API, only one file needs updating. When a new data type is needed (calories, blood oxygen), it gets added in one place.</p><h3>Key Takeaways</h3><ol><li>Check SDK availability on Android before calling anything. Health Connect may not exist on older devices.</li><li>.toISOString() is always UTC. If your app has users outside UTC, replace it with a timezone-aware library like dayjs.</li><li>aggregateRecord on Android sums all sources. There is no magic deduplication. Either filter by source (device-specific, risky in production) or let the user configure priority in Health Connect.</li><li>HealthKit hides which permissions were denied. Design your UI to work gracefully with partial data — every HealthData field is optional for a reason.</li><li>Wrap the callbacks. react-native-health is entirely callback-based. A single iosRead&lt;T&gt; promisify helper eliminates dozens of nested callback functions.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a35b80efe56" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built a Health App That Actually Understands Your Age — Here’s What I Learned]]></title>
            <link>https://medium.com/@developershanker95/i-built-a-health-app-that-actually-understands-your-age-heres-what-i-learned-af8ce2780989?source=rss-c35562a980bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/af8ce2780989</guid>
            <category><![CDATA[health-connect]]></category>
            <category><![CDATA[personal-project]]></category>
            <category><![CDATA[bmi-calculator]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[firebase]]></category>
            <dc:creator><![CDATA[Bhawana Shanker]]></dc:creator>
            <pubDate>Sun, 10 May 2026 04:23:29 GMT</pubDate>
            <atom:updated>2026-05-10T04:23:29.160Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Most BMI calculators are wrong for half the population. I spent a few weekends building one that isn’t, and along the way learned a lot about Firebase auth, dynamic content, and why “delete my account” is harder than it sounds.</em></p><h3>The Problem That Started It</h3><p>I was helping my younger cousin track her fitness goals when I noticed something odd: every BMI calculator we tried gave the same verdict regardless of who used it. A 13-year-old girl, a 30-year-old man, a 60-year-old woman — same formula, same categories, same advice.</p><p>That’s not just lazy product design. It’s medically misleading. The CDC explicitly says BMI for anyone under 20 should use age-and-sex-specific percentile charts, not the adult formula. And even for adults, BMI is a crude proxy for what we actually care about — body composition.</p><p>So I decided to build a small app that did this properly. I called it Let&#39;s Crack It. What started as a weekend project turned into a real lesson in how many things go into shipping even a “simple” health app.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DGX41OR1Ym8YE6fAs6JxDQ.png" /></figure><blockquote><strong>Lesson 1: Users Want Auth Choices, and That’s a Design Problem</strong></blockquote><p>Every tutorial I’ve ever read picks one auth method and runs with it. That’s fine for a demo. In practice, users have strong preferences. Some hate passwords. Some don’t trust Google. Some want to sign up before sharing their email.</p><p>I ended up implementing three auth flows side by side: Google Sign-In, passwordless email magic links, and phone OTP. The technical part was actually the easy bit — Firebase makes each of them work in under 30 lines of code. The hard part was the <em>plumbing</em>:</p><ul><li>After auth, how do you decide where to send the user — to onboarding or to home?</li><li>A phone-only user has no name or email. How do you render their profile?</li><li>A user who signed up with an email later wants to add Google. How do you avoid wiping their existing data?</li></ul><p>The answer to all three was the same pattern: a single users/{uid} document in Firestore that every auth flow writes tomerge: true, plus a profileComplete flag that gates onboarding. Once that flag is true, you trust it. Once it&#39;s false, you ask for the missing pieces.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*NEWTNOUkO6LEKVndhHiz6w.png" /></figure><p>The trickiest flow was the magic link. When a user taps the email link, your app opens via deep link — but the user’s email address isn’t in the URL. You have to remember it from when they originally requested the link. That meant adding AsyncStorage to the flow and listening for both Linking.getInitialURL() (app was closed) <em>and</em> Linking.addEventListener(&#39;url&#39;, ...) (app was backgrounded). Forget either one, and the flow silently breaks for half your users.</p><blockquote><strong>Lesson 2: BMI Is More Like Three Different Calculations</strong></blockquote><p>Here’s where the project got interesting. I’d assumed I’d just implement the standard formula and add some better category labels. Instead, I learned that there are essentially three different “right” answers depending on who’s asking.</p><p>For adults, raw BMI is a coarse signal. A 25-year-old woman with a BMI of 24 has a very different body composition from a 60-year-old man with the same BMI. The <a href="https://pubmed.ncbi.nlm.nih.gov/2043597/"><strong><em>Deurenberg formula (1991)</em></strong></a> addresses this by estimating body fat percentage from BMI, age, and sex. It’s not perfect — it’s a regression, not a measurement — but it’s dramatically better than the raw number.</p><p>For under-20s, you need percentile charts. The CDC publishes a dataset called LMS — three parameters (lambda, mu, sigma) per age in months, per sex — and you use them to compute a Z-score for the kid’s BMI relative to peers, then convert that to a percentile. This required implementing the standard normal CDF myself, since JavaScript doesn’t ship with one. I used the Abramowitz &amp; Stegun approximation, which gets you within 7.5×10⁻⁸ — well past anything that matters in this domain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/602/1*ovlcxBp7yt0HYlqewQ-AaA.png" /></figure><p>For users who haven’t told us their age yet, we fall back to the simple formula with a gentle nudge to complete their profile. You can’t show “32nd percentile” without knowing the date of birth.</p><p>What I didn’t expect was how much UI work this implied. A single BMI screen now had to display three different metrics (“body fat %”, “percentile”, or just “BMI”), three different category schemes, and explain to the user <em>why</em> their number meant what it meant. Designing that was harder than the math.</p><blockquote><strong>Lesson 3: Remote Config Should Be Your Default, Not an Afterthought</strong></blockquote><p>I shipped the first version with hardcoded motivational copy on the home screen. Two days later, I wanted to change one word. That meant a new build, App Store review, and a 24-hour wait.</p><p>Firebase Remote Config solves this by letting you push JSON to the app from a web dashboard. Update the value, and active users see it within minutes — no deploy, no review.</p><p>The pattern that worked best for me was <em>activate-then-fetch</em>: on app start, immediately apply whatever values are cached locally (fast startup), then fetch fresh values in the background. Combined with the real-time onConfigUpdated listener, the app stays current without any noticeable delay.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/606/1*lOn3aeYPhdQed5sr1cRt9g.png" /><figcaption>fig 3. All the list of articles are dynamic and can be changed by Firebase Remote config</figcaption></figure><p>The deeper lesson: anything that might change belongs in Remote Config. Marketing copy. Feature flags. A/B test parameters. Welcome messages. The cost of putting a string in Remote Config is essentially zero. The cost of putting it in your bundle and wanting to change it later is a full release cycle.</p><blockquote><strong>Lesson 4: “Delete My Account” Is the Feature Tutorials Skip</strong></blockquote><p>App stores now require apps to offer account deletion. I almost skipped it, thinking sign-out was enough. It’s not — and the difference matters legally.</p><p>Implementing it properly forced me to learn three things Firebase doesn’t make obvious:</p><p>Re-authentication is mandatory. Firebase Auth refuses to delete an account that hasn’t authenticated recently — it throws auth/requires-recent-login. So before deletion, you trigger a re-auth flow (a fresh Google Sign-In, in my case) and re-credential the user.</p><p>Firestore doesn’t cascade deletes. If you have a users/{uid}/bmiHistory subcollection and you delete the parent doc, the subcollection lives on as orphaned data. You have to enumerate it and batch-delete it manually before deleting the parent.</p><p>Order matters. Delete the subcollection first, then the user document, then finally the Auth record. Reverse the order, and you’ll fail authentication mid-flow because the user no longer exists.</p><p>This took maybe 40 lines of code total, but represents about 30% of the legal/compliance work in shipping a real app.</p><blockquote><strong>Lesson 5: Persist State, Don’t Refetch It</strong></blockquote><p>The first version of the app, called Firestore, on every launch, populates the home screen. It worked, but felt sluggish — you’d see a spinner for half a second every time the app opened.</p><p>The fix was redux-persist. The user&#39;s profile and BMI history live in a Redux slice, which gets serialized to AsyncStorage, and on next launch, it rehydrates instantly. Firestore only gets called when the user explicitly logs a new entry.</p><p>This is the kind of thing that doesn’t seem important until you experience the difference. A half-second delay on app open is the difference between an app that feels native and one that feels like a webpage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/606/1*wVxUwK_jDI0sxBOhYpW21A.png" /></figure><h3>What I’d Do Differently</h3><p>If I were starting over:</p><ul><li>Design the data model before any UI. I rewrote my Firestore schema twice because I didn’t think through how the BMI categorization would interact with the percentile method until I was already coding screens.</li><li>Wire Remote Config from day one. I retrofitted it after the first build and ended up moving a lot of strings around.</li><li>Treat account deletion as a launch requirement, not a v1.1 task. It touches the whole stack and is much easier to design in than to bolt on.</li><li>Skip “Forgot password” entirely. Magic links and Google Sign-In cover 99% of users without the support burden of password resets.</li></ul><h3>What’s Next</h3><p>The foundation is in place. The next round of work is more interesting than infrastructure:</p><ul><li>A trend chart on the progress screen so users can actually see improvement</li><li>Personalized insights via the Claude API (“Your weight has dropped 2kg over six weeks; here’s what that typically means at your activity level”)</li></ul><h3><strong>Update — Health Connect &amp; HealthKit Integration</strong></h3><p>Shortly after publishing this, I added wearable data support for both platforms:</p><ul><li>Android — Health Connect (Steps, Heart Rate, Sleep, Weight, Height)</li><li>iOS — Apple HealthKit (same data types)</li></ul><p>The same healthService.ts file handles both platforms behind a single public API: initHealthService() and readHealthData(). The caller never needs to know which platform it&#39;s on. What made this cleaner than expected was keeping all the platform branching inside the service layer. The useHealthData hook that screens consume is completely platform-agnostic.</p><p><strong><em>We will discuss this in the upcoming discussions.</em></strong></p><h3>The Real Takeaway</h3><p>The most surprising thing about this project wasn’t the math or the auth flows. It was how much of “building an app” is actually decisions about edge cases — what happens when a user has no profile yet, what happens when they tap a magic link in the wrong app, what happens when they want their data deleted, what happens when they’re 19 versus 20.</p><p>The code for any one of these is small. The judgment about how they fit together is the actual work. That’s the part the tutorials don’t teach you, and the part that’s most fun once you start paying attention to it.</p><p><em>If this resonated, follow for more deep-dives on shipping real-world mobile apps. The source for LetsCrackIt is on GitHub.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af8ce2780989" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How WebView Actually Works in React Native — and What Nobody Tells You About It]]></title>
            <link>https://medium.com/@developershanker95/how-webview-actually-works-in-react-native-and-what-nobody-tells-you-about-it-0900d1756cab?source=rss-c35562a980bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/0900d1756cab</guid>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[react-native-webview]]></category>
            <dc:creator><![CDATA[Bhawana Shanker]]></dc:creator>
            <pubDate>Thu, 30 Apr 2026 11:48:07 GMT</pubDate>
            <atom:updated>2026-04-30T11:48:07.539Z</atom:updated>
            <content:encoded><![CDATA[<p><em>I’ve been working with React Native, and still, WebView is one of those things that comes up in almost every project, but nobody really talks about it properly.</em></p><p>So here’s what I know — from actually using it in production, not from reading docs.</p><h3>What it is doing exactly</h3><p>react-native-webview is a package that renders a browser inside your app. On iOSWKWebViewOn Android, it uses the system WebView (the Chromium one that updates through the Play Store separately from Android OS).</p><p>The important thing to understand is — this is not React Native rendering anything. There’s no bridge to native components. The WebView just gets a box on the screen, and the browser engine paints pixels into it. React Native has zero idea what’s happening inside that box.</p><p>That’s both why it’s useful and why it causes problems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x19pQ7J2ABPNX-tYVKTSig.png" /></figure><h3>Where teams actually use it</h3><ol><li><strong>When the web team has already built the thing</strong></li></ol><p>This is the most common reason. The web team spent 3 months on a flow, it’s tested, it’s working. Why would mobile rebuild it from scratch? So you just load it in a WebView. Not the cleanest thing, but it’s a very real business decision.</p><p><strong>2. Third-party tools that don’t have a native SDK</strong></p><p>Chat widgets, feedback tools, and some KYC flows. If the vendor only gives you a JavaScript snippet, WebView is your only option. It’s not a workaround; it’s just how you integrate it.</p><p><strong>3. Content that keeps changing</strong></p><p>T&amp;C pages, help articles, legal stuff. If you put this in native, someone has to update the app every time legal changes a line. WebView means the web team edits it once, and all app versions see it immediately.</p><p><strong>Rendering complex HTML</strong></p><p>React Native’s Text component is good, but it&#39;s not a browser. If you&#39;re rendering a document with tables, nested formatting, mixed content — it&#39;s honestly easier to pass it as HTML to a WebView than to try and re-parse it into native components.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-pc2oPlbRo8aZvzIX64zuQ.png" /></figure><h3>The interesting use case — mixing WebView with native</h3><p>Okay, this is the part I actually want to talk about.</p><p>On one of the projects I worked on, there was a multi-step user journey that was already built and running on the web. The decision was made to load it in WebView inside the app instead of rebuilding it natively.</p><p>Fine. Except that one specific step in this journey was breaking inside WebView. Payments.</p><p>The payment SDK had deep link issues in the WebView’s sandboxed context. Bank redirects were opening in external browsers and losing the session. Some gateway iframes were rendering inconsistently on Android.</p><p>So we ended up with this flow:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dPMAlTtOFVneKRUn-G3LDA.png" /></figure><p>App → WebView → App → WebView.</p><p>It sounds messy, but it was actually clean once we got the communication right.</p><h3>How the communication works — postMessage and onMessage</h3><p>The way WebView and React Native talk to each other is through messages.</p><p>Web side sends a message like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xbfIlqgCKNeX33Svp_PRTA.png" /></figure><p>window.ReactNativeWebView only exists when the page is running inside a React Native WebView. So you can use this check to make the same web page work in both browser and in-app contexts.</p><p>React Native side listens with onMessage:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4T8PvA_AodmeB-41XDJtZQ.png" /></figure><p>A few things I’d mention here:</p><ul><li>useCallback matters on the handler — without it, you get a new function reference on every render, which causes unnecessary WebView re-renders</li><li>Always wrap the JSON.parse in try/catch — if the web side sends something malformed, your app shouldn’t crash</li><li>The window.ReactNativeWebView check on the web side is important, it lets the same codebase work in both browser and in-app</li></ul><h3>The Android back button — this one will bite you</h3><p>Imagine you have a WebView where the user navigates through 4 pages — step 1, step 2, step 3, step 4. They’re on step 4, and they press the Android hardware back button.</p><p>What do you think happens?</p><p>They go back to step 3, right?</p><p>No. They get kicked out of the WebView entirely and land back on the previous native screen.</p><p>That’s because Android back by default, pops the React Native navigation stack. It has no idea that the WebView had its own internal history going on. From React Native’s perspective, back means “go to the previous screen”, not “go back inside the box I’m rendering.”</p><p>So the user loses their entire progress. Not great.</p><p>The fix is BackHandler — You intercept the back press yourself and tell the WebView to handle it instead:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RpTvAN6UaOYAxCFacFA16A.png" /></figure><p>Okay, this works. But there’s a bug hiding in here that’s easy to miss — and we hit it in production.</p><p>canGoBack is a state variable. Inside the BackHandler listener, it gets captured as a closure at the time the effect runs. Even with canGoBack in the dependency array, there&#39;s a small window — the user navigates inside the WebView, the state hasn&#39;t updated yet, the user presses back, and the handler reads a stale false and lets the back event through.</p><p>User gets kicked out of the WebView. Again.</p><p>The fix is to stop using state for this and use a ref instead. Refs always give you the current value, no matter when you read them. No closure, no timing issue.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3zSe_z3f-HZHAnbzX9UZfg.png" /></figure><p>Actually, worth remembering this pattern beyond just WebView — any listener you register once (BackHandler, setInterval, addEventListener) that needs to read something that changes over time, use a ref. Not state. State in a one-time registered callback will always risk going stale.</p><h3>Security stuff you can’t ignore</h3><p>Think about what WebView is doing for a second.</p><p>You’re loading a URL inside your app. That URL renders whatever it wants. It can navigate to other URLs. It can run JavaScript. Your app is basically handing a browser engine a piece of paper and saying, “Do whatever this says.”</p><p>So what happens if that URL gets compromised? Or redirects to something it shouldn’t?</p><p>By default, your WebView just follows it. Silently. The user is now looking at something you didn’t intend to show them, and it’s inside your app.</p><p>That’s why you whitelist URLs. You tell the WebView upfront: you’re only allowed to navigate to these domains. Anything else gets blocked.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1022/1*NBVJNeZAw4qA9f1dgb2MDw.png" /></figure><p>Now even if something weird happens mid-flow, the WebView just stops instead of following a rogue redirect.</p><p>The other one is injectedJavaScript. This prop lets you run JavaScript directly inside the WebView&#39;s context — before the page finishes loading. It&#39;s useful for things like setting app info on the window object so the web page knows it&#39;s running inside your app.</p><p>But here’s the question — where is that JavaScript string coming from?</p><p>If it’s hardcoded, fine. If it’s coming from user input, an API response, or literally anywhere external, you now have an XSS risk. You’re injecting arbitrary code into a browser context inside your app. That’s bad.</p><p>Only ever inject static strings you control completely.</p><p>Also, a small gotcha: always end the string with true;. Android WebView silently fails if the last expression in the injected script doesn&#39;t evaluate to a string. It won&#39;t throw an error, it&#39;ll just not work, and you&#39;ll spend an hour wondering why.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9j2ZTVSfs4TmFqAb3XGdLw.png" /></figure><h3>Performance things to know</h3><p>Here’s something that surprised me when I first used WebView.</p><p>You open a screen. It’s a WebView. It’s blank for a second. Then the content appears. You think — okay, it’s loading, that’s normal.</p><p>But why is it slow? The screen is already mounted. React Native is already rendered. Why is there still a delay?</p><p>Because WebView isn’t loading a component. It’s booting up a browser. Every single time it mounts, it goes through the full sequence — DNS lookup, HTTPS handshake, server response, HTML parse, CSS parse, JavaScript execution. The whole thing. From scratch.</p><p>On good Wi-Fi, that might be 300–400ms. On a mid-range Android device on 4G — easily 1.5 to 2 seconds. That’s a long time to show the user nothing.</p><p>So always show a loading state. Don’t let the user stare at white.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zJKxBzcXtkRm0dqF9GBFFw.png" /></figure><p><strong>Another one</strong>: what happens when you try to put a pull-to-refresh or a swipe-to-dismiss gesture around a WebView?</p><p>It doesn’t work the way you’d expect.</p><p>WebView absorbs all touch events inside it. The browser is handling them, not React Native. So your gesture handler sitting outside the WebView never gets to see what the user’s finger is doing. The gestures compose fine with a native ScrollView or FlatList — but a WebView is a black box for touch.</p><p>If you really need gestures around a WebView, you end up doing onTouchStart / onTouchEnd tracking on the WebView itself, which is awkward and never feels fully native. Most of the time, it&#39;s just easier not to fight it.</p><p><strong>Last one</strong>: don’t mount multiple WebViews at the same time.</p><p>If you have a bottom tab bar and three of your tabs are WebViews, and React Native mounts all three at once to keep them warm, each one is running its own full browser context in memory. Three separate browser instances. On a device with 3GB RAM, which is a lot for Indian mid-range devices, this is going to be felt by the user.</p><p>Lazy mount your tabs if you’re doing this. Only mount the WebView when the tab is actually active.</p><h3>The thing that actually makes this work in a team</h3><p>The technical part is manageable. What made the mixed native + WebView flow actually maintainable was something simpler — agreeing on the contract before writing code.</p><p>Before building anything, we defined:</p><ul><li>What message types are the web side allowed to send</li><li>What is the payload shape for each one</li><li>Which URLs the WebView is allowed to navigate to</li></ul><p>That’s it. With that written down and agreed on, the web team and mobile team could move independently. Web could iterate on the journey. Mobile could build out whatever it needed to on the native side. Neither team was blocked by the other.</p><p>WebView as an interface between teams works when the interface is explicit.</p><h3>You’ve already used it. You just didn’t know.</h3><p>Next time you open one of these apps, notice when the screen feels slightly different — a tiny loading delay, a scroll that feels a bit off, or the back button behaving weirdly. That’s usually a WebView.</p><p><strong>Swiggy / Zomato</strong> — the help and support section. That’s not a native screen. It’s a WebView loading their support portal. They don’t want to push an app update every time they change a refund policy line.</p><p><strong>HDFC / ICICI banking apps</strong> — a lot of the informational pages, loan calculators, and offer detail screens are WebViews. Core banking is native; everything around it is web.</p><p><strong>PhonePe / Paytm</strong> — merchant offers, cashback detail pages, and some promotional screens. The web team owns that content; the app just frames it.</p><p><strong>Razorpay, CCAvenue, PayU</strong> — the actual payment checkout page you see inside any app? That’s a WebView. The payment SDK ships its own internal WebView with the checkout UI. Even “native payment” flows have a WebView in them somewhere.</p><p><strong>MakeMyTrip / Goibibo</strong> — hotel detail pages, some booking flows. Mix of native and WebView, depending on how fast that feature shipped.</p><p>The pattern is always the same — native for the core experience, WebView for the parts that need to move fast, change often, or come from a third party.</p><p>That’s honestly everything I wish I’d known before working with WebView in production. It’s not complicated once you’ve seen the patterns — but the stale closure bug, the Android back button, the payment flow handoff — these are things you only really understand after you’ve been burnt by them once.</p><p><em>Senior React Native Engineer. I write about things I’ve actually debugged.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0900d1756cab" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Firebase Auth in 2026 — Is It Still Worth It for Small Projects?]]></title>
            <link>https://medium.com/@developershanker95/firebase-auth-in-2026-is-it-still-worth-it-for-small-projects-0204c0398594?source=rss-c35562a980bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/0204c0398594</guid>
            <category><![CDATA[mobile-development]]></category>
            <category><![CDATA[firebase]]></category>
            <category><![CDATA[react-native]]></category>
            <dc:creator><![CDATA[Bhawana Shanker]]></dc:creator>
            <pubDate>Tue, 28 Apr 2026 13:10:05 GMT</pubDate>
            <atom:updated>2026-04-28T17:21:17.607Z</atom:updated>
            <content:encoded><![CDATA[<h3>How I implemented Phone, Google &amp; Passwordless Email auth for my health app — and what I’m building next</h3><h3>The Rabbit Hole Nobody Warns You About</h3><p>When I started building <strong>LetsCrackIt</strong> — a personal health app that helps you track health parameters and build a disciplined daily routine — I thought auth would be the easy part.</p><p>I was wrong.</p><p>Email login, Google Sign-In, phone OTP, passwordless flows, sessions, tokens, refresh logic — it’s a rabbit hole. And the moment you open Twitter or Reddit to find answers, everyone is either hyping Clerk, dunking on Firebase, or telling you to “just roll your own.”</p><p>So I did what any developer should do — I blocked out the noise, evaluated my options, and actually built it. Here’s everything I learned.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y2LrLZp_gpUPTetlKkIrAQ.png" /><figcaption>Firebase</figcaption></figure><h3>First, What Was I Actually Building?</h3><p>LetsCrackIt is a React Native app I’m building in my spare time. The core idea is simple: give users a clear picture of their health parameters — BMI, activity levels, nutrition — and help them build a daily routine that keeps them disciplined and consistent.</p><p>For this to work, users needed accounts. Personalised data, saved progress, daily streaks — none of that works without identity.</p><p>My requirements were straightforward:</p><ul><li>Small scale — personal project, not enterprise</li><li>React Native (not web)</li><li>Multiple login methods for better conversion</li><li>Free or nearly free to run</li><li>I didn’t want to manage my own auth infrastructure</li></ul><h3>The Options on the Table</h3><p>Before jumping to Firebase, I looked at the landscape properly. Here’s how I’d categorise it:</p><h3>Option 1 — Build It Yourself</h3><p>JWT tokens, bcrypt password hashing, your own database, refresh token rotation, session invalidation…</p><p>This makes sense only if <strong>auth is your product</strong>. For everything else, you’re reinventing a wheel that has already been engineered to death by teams far larger than yours. Skip it.</p><h3>Option 2 — BaaS (Backend as a Service)</h3><p>These are platforms where auth is one feature among many:</p><p><strong>Firebase Auth</strong></p><ul><li>10,000 auth users/month on the free Spark plan</li><li>No built-in UI — you build your own screens</li><li>Excellent React Native SDK via @react-native-firebase</li><li>Phone OTP, Google Sign-In, Email (password + passwordless) all supported natively</li><li>Sits perfectly alongside Firestore if you’re already in that ecosystem</li></ul><p><strong>Supabase Auth</strong></p><ul><li>50,000 users/month on free tier — more generous</li><li>Postgres-based — better if your app is SQL-heavy</li><li>One important caveat: <strong>projects pause after inactivity</strong> on the free plan. For a personal project you’re building slowly, this is a real pain.</li></ul><h3>Option 3 — Dedicated Auth Services</h3><p>These platforms exist purely for auth. It’s their only product:</p><p><strong>Clerk</strong></p><ul><li>Prebuilt UI components, fastest developer experience</li><li>Best suited for React/Next.js web apps</li><li>React Native support exists, but is less mature than Firebase</li></ul><p><strong>Auth0</strong></p><ul><li>Most feature-rich, enterprise-grade</li><li>Gets expensive fast beyond the free tier</li><li>Overkill for a personal project</li></ul><p><strong>Kinde</strong></p><ul><li>Newer player, generous free tier (10,500 MAU)</li><li>Worth watching, but the ecosystem is still maturing</li></ul><p><strong>Magic / Passwordless.dev</strong></p><ul><li>Specialise in magic link and OTP-based flows</li><li>Good if passwordless is your primary strategy</li></ul><h3>Why I Chose Firebase for LetsCrackIt</h3><p>Honestly? A few practical reasons:</p><p><strong>1. I was already using Firestore.</strong> Staying in the same ecosystem meant one SDK, one console, one billing account. The cognitive overhead reduction is real.</p><p><strong>2. Google Sign-In was near-zero config.</strong> Since Firebase and Google are the same ecosystem, wiring up Google auth took maybe 30 minutes including testing.</p><p><strong>3. The free tier is enough for what I need.</strong> 10k users/month for a personal project is not a constraint I’ll hit anytime soon.</p><p><strong>4. React Native support is excellent.</strong> The @react-native-firebase/auth package is well-maintained, actively updated, and has solid documentation. This matters — some services have React Native as an afterthought.</p><p><strong>5. No built-in UI is actually fine.</strong> I built my own login screens. This gave me complete control over design and UX, which matters for a health app where the onboarding experience directly affects retention.</p><h3>What I’ve Implemented So Far</h3><p>Here’s what’s live in LetsCrackIt today:</p><h3>📧 Passwordless Email Login</h3><p>No password to remember. User enters their email, gets a magic link, taps it, and they’re in. Firebase handles the link generation, verification, and session creation. Clean and simple.</p><h3>📱 Phone OTP</h3><p>User enters their phone number, gets an SMS OTP, verifies it. Firebase abstracts away the entire SMS delivery and verification flow. What would have taken weeks of Twilio integration took a day.</p><h3>🔵 Google Sign-In</h3><p>One tap, done. Works beautifully on Android. Because of the Firebase + Google ecosystem overlap, this is genuinely the easiest auth method to implement in React Native.</p><h3>What I’m Planning Next</h3><p>Auth for LetsCrackIt isn’t done. Here’s the roadmap:</p><h3>🍎 Apple Sign-In</h3><p>Mandatory for iOS apps that offer social login — Apple requires it if you offer any third-party sign-in option. Firebase supports it natively, so this is next on the list.</p><h3>🔐 Biometric Authentication (Fingerprint / Face ID)</h3><p>This isn’t a separate auth method — it’s a <strong>local security layer on top of an existing session</strong>. The pattern is:</p><ul><li>User logs in once via email/Google/phone</li><li>On subsequent opens, device biometric unlocks the session locally</li><li>Firebase session token is stored securely in device keychain</li></ul><p>Libraries like react-native-biometrics handle this elegantly alongside Firebase.</p><h3>🔗 Linking Multiple Providers</h3><p>A user might sign up with Google and later want to also link their phone number to the same account. Firebase’s linkWithCredential API makes this possible — one account, multiple login methods.</p><h3>Is Firebase “Dead” Like Twitter Says?</h3><p>Let me address this directly because if you’ve been on dev Twitter recently, the Firebase hate is loud.</p><p>Here’s what people are actually angry about:</p><ul><li><strong>Firestore pricing</strong> — unpredictable read/write billing that can spike unexpectedly</li><li><strong>NoSQL data modeling</strong> — if you don’t model your data carefully upfront, you pay for it later</li><li><strong>Vendor lock-in</strong> — Firebase is deeply Google, migrating away is non-trivial</li></ul><p>All of that is fair criticism. But notice what’s <strong>not</strong> in that list — Firebase Auth. The auth layer has none of these problems. It’s flat-rate free up to 10k users, there’s no complex data modeling involved, and the API is stable and well-documented.</p><p>The rant is about Firestore. Firebase Auth is a separate conversation entirely.</p><p>Firebase is 14 years old, and Google actively maintains it. The market got more options — Supabase, Clerk, Kinde — and that’s healthy. But more options don’t mean Firebase is irrelevant. It means you have better choices for different contexts.</p><h3>The Scalability Question</h3><p>Right now, Let&#39;s Crack It is a personal project. But I’m thinking about what “scaling up” would look like, and the auth foundation matters here.</p><p>Firebase Auth scales with you. The same implementation that works for 100 users works for 100,000 — you just move from the Spark to Blaze plan, and the auth itself remains free. The Firestore costs scale, but that’s a separate decision.</p><p>If the app grows to a point where I need:</p><ul><li>Complex role-based access control → I’d evaluate Auth0 or a custom layer</li><li>Multi-tenancy → Clerk handles this well</li><li>Full data ownership → Self-hosted Supabase becomes attractive</li></ul><p>But I’m not building for those problems today. The rule I follow: <strong>solve the problem in front of you, build with the ability to migrate later.</strong> Firebase Auth gives me that — it’s not a dead end.</p><h3>My Honest Recommendation</h3><p>If you’re building a personal project or small-scale app in React Native:</p><ul><li><strong>Already using Firebase/Firestore?</strong> → Firebase Auth. No question.</li><li><strong>Need prebuilt login UI fast?</strong> → Clerk (if web-first) or Auth0</li><li><strong>Postgres-based app?</strong> → Supabase Auth</li><li><strong>iOS app with social login?</strong> → Make sure Apple Sign-In is in your plan from day one</li><li><strong>Building slowly on free tier?</strong> → Watch Supabase’s inactivity pause behaviour</li></ul><p>The best auth service is the one you actually ship with. Don’t let the perfect be the enemy of the deployed.</p><h3>What’s Next for LetsCrackIt</h3><p>Beyond auth, the app is coming together. The core health parameter tracking is built, daily routine features are in progress, and I’m integrating health platform APIs (Samsung Health, Google Fit, ExerciseDB) to make the data richer and more automatic.</p><p>Auth was the foundation. Everything else builds on top of it.</p><p>If you’re building something similar — or have opinions on auth services I haven’t mentioned — I’d love to hear from you in the comments.</p><p><em>Tags: React Native, Firebase, Authentication, Mobile Development, Side Projects, JavaScript</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0204c0398594" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I’m Using AI to Improve My Engineering Thinking (After 7 Years in Industry)]]></title>
            <link>https://medium.com/@developershanker95/how-im-using-ai-to-improve-my-engineering-thinking-after-5-years-in-industry-511be9b1d6ed?source=rss-c35562a980bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/511be9b1d6ed</guid>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Bhawana Shanker]]></dc:creator>
            <pubDate>Tue, 21 Apr 2026 17:17:29 GMT</pubDate>
            <atom:updated>2026-04-21T17:19:52.878Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Not to write code for me. To find out how much I actually understand.</em></p><p>I’ve been a software engineer for more than 7 years now. I’ve shipped features to production, debugged things that kept me up at night, and reviewed pull requests. Most of the time, I know what I’m doing.</p><p>Then I started preparing for senior-level interviews — and realized I had a problem.</p><p>Not with coding. Not with React Native, Redux, TypeScript, or any of the tools I work with every day. The problem was something else and more uncomfortable: <strong>I could build things, but I couldn’t fully explain.</strong></p><h3>The Gap Nobody Talks About</h3><p>When you’re deep in a product for years, you develop a kind of habit. You know <em>what</em> to do without always knowing <em>why</em> it works. You fix bugs by pattern recognition. You make architecture decisions based on what’s worked before. You ship.</p><p>That’s not a bad thing — it’s experience. But it creates gaps.</p><p>For me, those gaps showed up the moment I started asking myself interview-style questions. <strong><em>Why does React Native’s New Architecture replace the bridge with JSI? What problem does it actually solve?</em></strong> I had used the new architecture. I had opinions about it. But when I tried to articulate the reasoning from first principles, I was away from the concept&#39;s technicalities.</p><p>Five years in, and I was struggling to explain things I used every week.</p><h3>What I Tried (And What Actually Worked)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wO6TSuUJHmwATi43FREnJA.jpeg" /></figure><p>I tried going through the documentation. Nothing goes to my brain. I tried YouTube deep-dives. Better, but hard to pause and interrogate. I tried writing notes. Useful, but I was just rephrasing things I half-understood.</p><p>Then I started using AI differently — not to generate code, but to <strong>think out loud with</strong>.</p><p>The shift was in how I framed my questions. Instead of asking <em>“what is JSI?”</em>, I started asking things like:</p><ul><li><em>“I’m a senior engineer preparing for interviews. I know JSI replaces the old bridge, but explain the actual bottleneck the old bridge created, like I need to defend this in a technical round.”</em></li><li><em>“I think I understand stale closures, but here’s a bug I hit in production — tell me if my mental model is actually correct or if I’m rationalizing.”</em></li><li><em>“Ask me questions about Redux middleware like you’re interviewing me, then tell me where my answers are weak.”</em></li></ul><p>That last one was uncomfortable. In a useful way.</p><h3>What Changed</h3><p>The thing I noticed pretty quickly: <strong>the quality of AI’s response is directly proportional to the quality of your question.</strong> And writing a good question requires you to have knowledge about it. It requires you to identify the edge of your understanding, which is itself a skill.</p><p>My 5+ years didn’t become irrelevant. They became the foundation for better questions. I knew <em>what</em> I didn’t know, because I’d hit those walls in real production code. I’d debugged a stale closure in a modal that was causing wrong data to persist. I’d traced a Redux store timing bug that only appeared under Hermes in a release build. I had context. AI gave me the language and the framework to connect the dots.</p><p>What I ended up building wasn’t just interview prep notes. It was a cleaner mental model of things I’d been using on autopilot.</p><h3>The Honest Part</h3><p>I want to be straight about something: this isn’t a story about AI being magic. There were moments where I’d get an explanation, think I understood it, and then fail to articulate it in my own words an hour later. That’s not AI’s failure — that’s the gap between reading comprehension and actual retention.</p><p>The tool didn’t fix that. What fixed it was using AI to <em>test</em> myself, not just explain to me. Asking it to expose the gaps. Asking it to give me the version where the concept breaks down. Asking it to tell me what I’d need to understand <em>next</em> to go one level deeper.</p><h3>If You’re in the Same Place</h3><p>If you’re a mid or senior engineer who has been heads-down in a product for years and now feels that quiet anxiety — <em>I ship, but could I explain this? Could I defend this architecture in a room of smart people?</em> — I don’t think the answer is to go back to basics.</p><p>The answer is to surface what you already know, find the edges where it gets fuzzy, and go deep on exactly those spots.</p><p>AI, used well, is surprisingly good at that. Not because it’s smarter than you. But because it’s infinitely patient, available at 11 pm, and will keep asking follow-up questions until you either understand something or admit that you don’t.</p><p>For me, that honesty — with myself, about what I actually understood — was the whole point.</p><p><em>If this resonated, I’d love to know what gaps you’ve been quietly carrying. Drop a comment — turns out most of us have the same ones.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=511be9b1d6ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Compulsion of A Mother]]></title>
            <link>https://medium.com/@developershanker95/the-compulsion-of-a-mother-2d3df8ae0548?source=rss-c35562a980bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d3df8ae0548</guid>
            <category><![CDATA[working-women]]></category>
            <category><![CDATA[motherhood]]></category>
            <category><![CDATA[women]]></category>
            <dc:creator><![CDATA[Bhawana Shanker]]></dc:creator>
            <pubDate>Sun, 13 Apr 2025 13:54:52 GMT</pubDate>
            <atom:updated>2025-04-13T13:54:52.013Z</atom:updated>
            <content:encoded><![CDATA[<p>It’s 7:15 in the morning. The whistle of the pressure cooker wakes me up — a sound that has now replaced my alarm clock during this semester break. Life is slow these days, peaceful even. I open my eyes halfway and feel the morning light trickling in.</p><p>“Uth gayi beta?” my mom asks gently.</p><p>“Ha,” I mumble, still half-asleep.</p><p>I finally get out of bed and see her getting ready for school. Yes, my mother is a primary school teacher. I blink a few times to clear my vision and take in the familiar sight — her sari neatly pinned, her bag packed, and a quick bite of roti in her hand.</p><p>I suddenly feel a pang of longing. <em>Why does she always have to go?</em> I came home for the holidays, hoping for long conversations, shared meals, and maybe a movie or two. But she’s always working.</p><p>“Maa, please aaj mat jao na,” I plead.</p><p>“Hainn? Kyu? Tabiyat theek hai tumhari?” she asks, immediately touching my forehead with concern.</p><p>“No Maa… it’s not that. Is it necessary to go every day? I just want to spend some time with you. Why don’t you ever take me seriously? Can’t you take a day off?” I ask, hoping she’ll stay, just this once.</p><p>She smiles and says softly, “Jaana zaruri hai na beta. I’ll try to come back early.”</p><p>I hug her and mutter, “Okay… let’s see how early you come.”</p><p>Then, almost instinctively, I rush to help her — packing her lunch, and filling her water bottle, while she hurriedly finishes a bite. She’s always in a rush. Every morning at 4:30, she’s up and in the kitchen, preparing meals for the entire day. And yet, she rarely eats much for breakfast. That part always tugs at my heart.</p><p>I wave her goodbye with a smile, watching her leave like I used to when I was a little girl — sitting at the table with my breakfast, watching her dress up for work, and dreaming of becoming like her someday. Strong. Independent. Confident. Someone who earns her own money and stands tall in the world.</p><p>She raised me so well. And yet, it feels unfair that I’m not there with her now when she’s retired — the very time I used to crave as a child. But life happened. Work, distance, responsibilities. Still, I try to make up for lost time, to let her know I’m here. I’m around.</p><p>But <em>being around</em> isn’t the same as <em>being present</em>. Especially for parents. Especially for mothers. They become the quiet role models we never asked for but always needed.</p><p>Living and working alone for the past eight years has taught me how hard solitude can be. The quiet fear, the hidden anxieties, the longing for your people — it eats at you, slowly. It shows up in your health, in your sleep, in your silence. Maybe that’s why people settle down — to have someone, even if it’s not your parents, who stands by you during the tough times.</p><p>As a child, I made mental promises to myself — <em>I won’t do this when I grow up. I won’t make my child feel this way.</em> But life, as it always does, teaches you otherwise. Work matters. Money matters. Family matters. You run after all of it, even if it means making your child a little upset sometimes.</p><p>I was hurt then. And maybe, unintentionally, I’ll hurt my daughter too someday. But just like my mother did it for me, I’ll do it for her. For her future. For her strength.</p><p>Because that’s the compulsion of a mother — the quiet sacrifices, the endless rush, and the unwavering love, all stitched together in a sari and a 4:30 a.m. wake-up call.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d3df8ae0548" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Momentary Bond]]></title>
            <link>https://medium.com/@developershanker95/a-momentary-bond-bfca79223f76?source=rss-c35562a980bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/bfca79223f76</guid>
            <category><![CDATA[saturday-morning]]></category>
            <category><![CDATA[emotions-and-feelings]]></category>
            <category><![CDATA[love]]></category>
            <category><![CDATA[dogs]]></category>
            <dc:creator><![CDATA[Bhawana Shanker]]></dc:creator>
            <pubDate>Sat, 10 Aug 2024 18:50:22 GMT</pubDate>
            <atom:updated>2024-08-10T19:05:23.326Z</atom:updated>
            <content:encoded><![CDATA[<p>It was a typical quiet and calm Saturday morning. Most city dwellers sleep in on weekends to recover from the hectic pace of the week. The usual noise was absent, creating a peaceful atmosphere I truly enjoy. Normally, I’d be out jogging, but today, market day, I decided to explore with a pocket bag and my phone.</p><p>After carefully selecting papayas and bell peppers, I returned home with a heavy load. On my way back, I often see dog owners taking their pets for walks. As a dog lover, I always admire the sight, but my responsibilities and strict rental agreement prevent me from having a pet.</p><p>Today, I encountered a woman with two adorable puppies. To spend more time with them, I took a longer route home. We exchanged greetings, and the puppies immediately took a liking to me. I’ve heard dogs can sense your emotions, and I’m always overjoyed around them. Their tails wagged enthusiastically. Reluctantly, I continued my journey, wishing I could have a dog.</p><p>Approaching my apartment building, I spotted a young dog, about eight or nine months old, emerging from the basement. Unlike Lucy, my neighbor’s corgi, who usually greets me at the stairs, this dog was a stranger without a collar or leash. The humidity and heavy bag slowed my pace, and I soon realized I was being followed. The dog continued to follow me quietly, even after I reached the second floor. When I stopped to get my keys, the dog started wagging its tail expectantly. Feeling overwhelmed, I ignored it and entered my apartment, closing the door in its face.</p><p>Guilt washed over me. Just moments ago, I’d wished for a dog, and now I’d turned one away. Curiosity got the better of me, and I peeked through the peephole to find the dog still sitting there. I considered offering it food but hesitated, worried about the potential consequences. After fifteen minutes, it was still there, so I decided to take a chance. I grabbed two slices of bread and opened the door, but the dog was gone.</p><p>I searched the building but couldn’t find it. Then I spotted the dog in the distance. Calling to it with the bread, I was relieved when it ran towards me. It devoured the food quickly. I stroked its fur, trying to comfort it. The dog seemed abandoned and whimpered, nuzzling my hand. I wished I could keep it but knew I couldn’t. With a heavy heart, I said goodbye. The dog tried to follow me but stopped when I gestured for it to stay.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/564/1*I-vd2n8pG7a3mLtEJPBqSg.jpeg" /><figcaption>“I wish I could keep you forever”</figcaption></figure><p>It’s amazing how someone seeking love can find you just when you’re longing to give it. In this case, it was a dog and a human. I hope we can all learn from this experience and be more open to offering help and kindness to others. It enriches our lives in countless ways.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bfca79223f76" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Networking vs Isolation in your late 20s (post-pandemic)]]></title>
            <link>https://medium.com/@developershanker95/networking-vs-isolation-in-your-late-20s-post-pandemic-f160b07babdc?source=rss-c35562a980bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/f160b07babdc</guid>
            <category><![CDATA[late20s]]></category>
            <category><![CDATA[corporate-culture]]></category>
            <category><![CDATA[networking]]></category>
            <category><![CDATA[work-from-home]]></category>
            <category><![CDATA[isolation]]></category>
            <dc:creator><![CDATA[Bhawana Shanker]]></dc:creator>
            <pubDate>Sun, 26 Mar 2023 15:16:45 GMT</pubDate>
            <atom:updated>2024-03-02T03:37:33.403Z</atom:updated>
            <content:encoded><![CDATA[<p>As we all know when the pandemic hit in 2020, we all grounded ourselves. Somewhere, introverts, like me, were relieved that we don’t need to socialize in workplaces. Everything became online and we were much at the peace getting things. but this process was too addictive. Our generation, mostly millennials already much suffered in the place of socializing. Although It makes much more peace to most of us if we don&#39;t have to meet people offline. We even don’t feel good opening our cameras in our office or at social meeting calls.</p><p>As we know, being in corporates we spent a large amount of time in the office with coworkers. Sahil Bloom, Managing Partner of SRB Ventures, in one of his tweets says that we spent a lot of our life around coworkers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OkkkhI_uu7kQa_zzQ-3_LQ.png" /></figure><p>So here the pros and cons of WFH are very necessary to discuss.</p><p>Being isolated for me personally made me very restful during the pandemic times but now after being in it for almost 3 years I am a bit off in restlessness with this WFH system. Every banner saying <strong><em>#WFHisNewNormal </em></strong>is kind of a danger to our social anxiety.</p><p>As the CEO of Cred, Kunal Shah discussed earlier that it&#39;s not fit for the long run it is impacting our learning and skill development.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HpWFi5QeKirgLor9CUOK_Q.png" /></figure><p>Living isolated also has its own benefit, but if it’s prolonged it can have some dangerous issues. Here are some pros and cons to discuss.</p><h3><strong>Networking</strong>:</h3><p>Pros:</p><ul><li>You can build relationships with people who can support and guide you in your personal and professional life.</li><li>You can learn new skills and knowledge by sharing information and ideas with others.</li><li>You can expand your social circle and develop a sense of community.</li><li>You can increase your chances of finding new opportunities, whether it’s for jobs, business partnerships, or personal projects.</li></ul><p>Cons:</p><ul><li>Networking can be time-consuming and requires effort and commitment.</li><li>You may feel pressure to maintain relationships, attend events, and stay active in your network.</li><li>You may encounter people who are not supportive or who have conflicting interests.</li><li>You may have to deal with competition or jealousy within your network.</li></ul><h3>Isolation :</h3><p>Pros:</p><ul><li>You can have more time and space to focus on your personal goals and hobbies.</li><li>You can enjoy peace and minimize distractions.</li><li>You can avoid drama or conflicts with others.</li><li>You can develop self-sufficiency and independence.</li></ul><p>Cons:</p><ul><li>Isolation living can be lonely and may lead to social isolation and depression.</li><li>You may lack support or guidance from others.</li><li>You may miss out on opportunities or experiences that come from interacting with others.</li><li>You may become too comfortable in your routine and lose motivation to explore new things.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/701/1*yAk1pv9s9xfOQqM8d-SJeQ.png" /><figcaption>Source: Hirect.in (<a href="https://www.hirect.in/blog/working-from-home-what-are-the-pros-and-cons/">https://www.hirect.in/blog/working-from-home-what-are-the-pros-and-cons/</a>)</figcaption></figure><p>Mostly the conclusion is that being at home for work might seem easy and fruitful for us now. Even if I wanted to be in WFH style It might impact our soft skills. It might create miscommunications too. I support <strong>HYBRID</strong> culture in the office so that we can be balanced in this place. But it&#39;s up to you how you want to manage this ratio of Isolation and networking in your life. Just analyze and configure according to it your life.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f160b07babdc" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>